From 563ebaef09c309fc1bc7a7c1f60c08f72159e8c1 Mon Sep 17 00:00:00 2001
From: Markus Quaritsch <markus.quaritsch@tugraz.at>
Date: Thu, 14 Feb 2019 16:31:37 +0100
Subject: [PATCH] add new fields to sum file
---
.../VectoCommon/Models/CertificationMethod.cs | 6 +
.../AbstractSimulationDataAdapter.cs | 1 +
.../DeclarationDataAdapter.cs | 2 +-
.../Models/Declaration/ADASCombinations.cs | 7 +
.../Models/Simulation/Data/ModalResult.cs | 68 ++--
.../Simulation/Data/ModalResultField.cs | 2 +
.../Data/CombustionEngineData.cs | 2 +
.../SimulationComponent/Data/VehicleData.cs | 2 +-
.../Impl/EngineAuxiliary.cs | 8 +-
.../Impl/TorqueConverter.cs | 1 +
.../OutputData/SummaryDataContainer.cs | 353 ++++++++++++++----
.../OutputData/XML/XMLCustomerReport.cs | 2 +-
.../OutputData/XML/XMLManufacturerReport.cs | 2 +-
13 files changed, 338 insertions(+), 118 deletions(-)
diff --git a/VectoCommon/VectoCommon/Models/CertificationMethod.cs b/VectoCommon/VectoCommon/Models/CertificationMethod.cs
index 5c83d6fa21..d72d5ffa04 100644
--- a/VectoCommon/VectoCommon/Models/CertificationMethod.cs
+++ b/VectoCommon/VectoCommon/Models/CertificationMethod.cs
@@ -45,8 +45,14 @@ namespace TUGraz.VectoCommon.Models
public static class CertificationMethodHelper
{
+
+
public static string ToXMLFormat(this CertificationMethod method)
{
+ return GetName(method);
+ }
+
+ public static string GetName(this CertificationMethod method) {
switch (method) {
case CertificationMethod.StandardValues:
return "Standard values";
diff --git a/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/AbstractSimulationDataAdapter.cs b/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/AbstractSimulationDataAdapter.cs
index 8399e5d291..fc23ef472f 100644
--- a/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/AbstractSimulationDataAdapter.cs
+++ b/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/AbstractSimulationDataAdapter.cs
@@ -129,6 +129,7 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
ModelName = data.Model,
Date = data.Date,
CertificationNumber = data.CertificationNumber,
+ CertificationMethod = CertificationMethod.Measured,
DigestValueInput = data.DigestValue != null ? data.DigestValue.DigestValue : "",
Displacement = data.Displacement,
IdleSpeed = data.IdleSpeed,
diff --git a/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/DeclarationDataAdapter.cs b/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/DeclarationDataAdapter.cs
index 5ce2c344b5..611504f19f 100644
--- a/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/DeclarationDataAdapter.cs
+++ b/VectoCore/VectoCore/InputData/Reader/DataObjectAdapter/DeclarationDataAdapter.cs
@@ -160,7 +160,7 @@ namespace TUGraz.VectoCore.InputData.Reader.DataObjectAdapter
{
return new VehicleData.ADASData {
EngineStopStart = adas.EngineStopStart,
- EcoRollWithoutengineStop = adas.EcoRollWitoutEngineStop,
+ EcoRollWithoutEngineStop = adas.EcoRollWitoutEngineStop,
EcoRollWithEngineStop = adas.EcoRollWithEngineStop,
PredictiveCruiseControl = adas.PredictiveCruiseControl
};
diff --git a/VectoCore/VectoCore/Models/Declaration/ADASCombinations.cs b/VectoCore/VectoCore/Models/Declaration/ADASCombinations.cs
index ca27f2c472..6e4d470510 100644
--- a/VectoCore/VectoCore/Models/Declaration/ADASCombinations.cs
+++ b/VectoCore/VectoCore/Models/Declaration/ADASCombinations.cs
@@ -35,6 +35,7 @@ using System.Data;
using System.Linq;
using TUGraz.VectoCommon.Exceptions;
using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
using TUGraz.VectoCore.Utils;
namespace TUGraz.VectoCore.Models.Declaration
@@ -105,5 +106,11 @@ namespace TUGraz.VectoCore.Models.Declaration
return Lookup(
adas.EngineStopStart, adas.EcoRollWitoutEngineStop, adas.EcoRollWithEngineStop, adas.PredictiveCruiseControl);
}
+
+ internal ADASCombination Lookup(VehicleData.ADASData adas)
+ {
+ return Lookup(
+ adas.EngineStopStart, adas.EcoRollWithoutEngineStop, adas.EcoRollWithEngineStop, adas.PredictiveCruiseControl);
+ }
}
}
diff --git a/VectoCore/VectoCore/Models/Simulation/Data/ModalResult.cs b/VectoCore/VectoCore/Models/Simulation/Data/ModalResult.cs
index 876ebfea81..96d13b1cc6 100644
--- a/VectoCore/VectoCore/Models/Simulation/Data/ModalResult.cs
+++ b/VectoCore/VectoCore/Models/Simulation/Data/ModalResult.cs
@@ -29,38 +29,38 @@
* Martin Rexeis, rexeis@ivt.tugraz.at, IVT, Graz University of Technology
*/
-using System;
-using System.ComponentModel;
-using System.Data;
-using System.Runtime.Serialization;
-using TUGraz.VectoCommon.Utils;
-
-// ReSharper disable InconsistentNaming
-
-namespace TUGraz.VectoCore.Models.Simulation.Data
-{
- [DesignerCategory("")] // Full qualified attribute needed to disable design view in VisualStudio
- [Serializable]
- public class ModalResults : DataTable
- {
- public static class ExtendedPropertyNames
- {
- public const string Decimals = "decimals";
- public const string OutputFactor = "outputFactor";
- public const string ShowUnit = "showUnit";
- }
-
- protected ModalResults(SerializationInfo info, StreamingContext context) : base(info, context) {}
-
- public ModalResults()
- {
- foreach (var value in EnumHelper.GetValues<ModalResultField>()) {
- var col = new DataColumn(value.GetName(), value.GetAttribute().DataType) { Caption = value.GetCaption() };
- col.ExtendedProperties[ExtendedPropertyNames.Decimals] = value.GetAttribute().Decimals;
- col.ExtendedProperties[ExtendedPropertyNames.OutputFactor] = value.GetAttribute().OutputFactor;
- col.ExtendedProperties[ExtendedPropertyNames.ShowUnit] = value.GetAttribute().ShowUnit;
- Columns.Add(col);
- }
- }
- }
+using System;
+using System.ComponentModel;
+using System.Data;
+using System.Runtime.Serialization;
+using TUGraz.VectoCommon.Utils;
+
+// ReSharper disable InconsistentNaming
+
+namespace TUGraz.VectoCore.Models.Simulation.Data
+{
+ [DesignerCategory("")] // Full qualified attribute needed to disable design view in VisualStudio
+ [Serializable]
+ public class ModalResults : DataTable
+ {
+ public static class ExtendedPropertyNames
+ {
+ public const string Decimals = "decimals";
+ public const string OutputFactor = "outputFactor";
+ public const string ShowUnit = "showUnit";
+ }
+
+ protected ModalResults(SerializationInfo info, StreamingContext context) : base(info, context) {}
+
+ public ModalResults()
+ {
+ foreach (var value in EnumHelper.GetValues<ModalResultField>()) {
+ var col = new DataColumn(value.GetName(), value.GetAttribute().DataType) { Caption = value.GetCaption() };
+ col.ExtendedProperties[ExtendedPropertyNames.Decimals] = value.GetAttribute().Decimals;
+ col.ExtendedProperties[ExtendedPropertyNames.OutputFactor] = value.GetAttribute().OutputFactor;
+ col.ExtendedProperties[ExtendedPropertyNames.ShowUnit] = value.GetAttribute().ShowUnit;
+ Columns.Add(col);
+ }
+ }
+ }
}
\ No newline at end of file
diff --git a/VectoCore/VectoCore/Models/Simulation/Data/ModalResultField.cs b/VectoCore/VectoCore/Models/Simulation/Data/ModalResultField.cs
index a02b090f34..7a8d100553 100644
--- a/VectoCore/VectoCore/Models/Simulation/Data/ModalResultField.cs
+++ b/VectoCore/VectoCore/Models/Simulation/Data/ModalResultField.cs
@@ -268,6 +268,8 @@ namespace TUGraz.VectoCore.Models.Simulation.Data
[ModalResultField(typeof(SI), "P_TC_out [kW]", outputFactor: 1e-3)] P_TC_out,
+ [ModalResultField(typeof(SI), "P_TC_in [kW]", outputFactor: 1e-3)] P_TC_in,
+
/// <summary>
/// [kW] Power loss at the torque converter.
/// </summary>
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Data/CombustionEngineData.cs b/VectoCore/VectoCore/Models/SimulationComponent/Data/CombustionEngineData.cs
index 9f7bbca59f..f740f75e8c 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Data/CombustionEngineData.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Data/CombustionEngineData.cs
@@ -115,6 +115,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data
MaxTorqueDeclared = MaxTorqueDeclared,
FuelData = FuelData,
ADASCorrectionFactor = ADASCorrectionFactor,
+ CertificationNumber = CertificationNumber,
+ CertificationMethod = CertificationMethod,
};
}
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Data/VehicleData.cs b/VectoCore/VectoCore/Models/SimulationComponent/Data/VehicleData.cs
index eedec88779..4bdc942f18 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Data/VehicleData.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Data/VehicleData.cs
@@ -219,7 +219,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data
public class ADASData
{
public bool EngineStopStart { get; internal set; }
- public bool EcoRollWithoutengineStop { get; internal set; }
+ public bool EcoRollWithoutEngineStop { get; internal set; }
public bool EcoRollWithEngineStop { get; internal set; }
public PredictiveCruiseControlType PredictiveCruiseControl { get; internal set; }
}
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Impl/EngineAuxiliary.cs b/VectoCore/VectoCore/Models/SimulationComponent/Impl/EngineAuxiliary.cs
index 0697faa378..afd1050fac 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Impl/EngineAuxiliary.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Impl/EngineAuxiliary.cs
@@ -76,10 +76,10 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
Add(auxId, _ => DataBus.CycleData.LeftSample.AdditionalAuxPowerDemand);
}
- public void AddCycle(string auxId, Func<DrivingCycleData.DrivingCycleEntry, Watt> powerLossFunc)
- {
- Add(auxId, _ => powerLossFunc(DataBus.CycleData.LeftSample));
- }
+ public void AddCycle(string auxId, Func<DrivingCycleData.DrivingCycleEntry, Watt> powerLossFunc)
+ {
+ Add(auxId, _ => powerLossFunc(DataBus.CycleData.LeftSample));
+ }
/// <summary>
/// Adds an auxiliary which calculates the demand based on a aux-map and the engine speed.
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Impl/TorqueConverter.cs b/VectoCore/VectoCore/Models/SimulationComponent/Impl/TorqueConverter.cs
index d66de46580..fbca2c4d51 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Impl/TorqueConverter.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Impl/TorqueConverter.cs
@@ -378,6 +378,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
container[ModalResultField.P_TC_out] = CurrentState.OutTorque * avgOutVelocity;
container[ModalResultField.P_TC_loss] = CurrentState.InTorque * avgInVelocity -
CurrentState.OutTorque * avgOutVelocity;
+ container[ModalResultField.P_TC_in] = CurrentState.InTorque * avgInVelocity;
}
protected override void DoCommitSimulationStep()
diff --git a/VectoCore/VectoCore/OutputData/SummaryDataContainer.cs b/VectoCore/VectoCore/OutputData/SummaryDataContainer.cs
index 59b85ffe3c..0efb634007 100644
--- a/VectoCore/VectoCore/OutputData/SummaryDataContainer.cs
+++ b/VectoCore/VectoCore/OutputData/SummaryDataContainer.cs
@@ -30,6 +30,7 @@
*/
using System;
+using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Runtime.CompilerServices;
@@ -190,6 +191,41 @@ namespace TUGraz.VectoCore.OutputData
public const string NUM_AXLES_NON_DRIVEN = "Number axles vehicle non-driven [-]";
public const string NUM_AXLES_TRAILER = "Number axles trailer [-]";
+ public const string VEHICLE_FUEL_TYPE = "Vehicle fuel type [-]";
+ public const string AIRDRAG_MODEL = "AirDrag model [-]";
+ public const string SLEEPER_CAB = "Sleeper cab [-]";
+ public const string DECLARED_RRC_AXLE1 = "Declared RRC axle 1 [-]";
+ public const string DECLARED_FZISO_AXLE1 = "Declared FzISO axle 1 [N]";
+ public const string DECLARED_RRC_AXLE2 = "Declared RRC axle 2 [-]";
+ public const string DECLARED_FZISO_AXLE2 = "Declared FzISO axle 2 [N]";
+ public const string DECLARED_RRC_AXLE3 = "Declared RRC axle 3 [-]";
+ public const string DECLARED_FZISO_AXLE3 = "Declared FzISO axle 3 [N]";
+ public const string DECLARED_RRC_AXLE4 = "Declared RRC axle 4 [-]";
+ public const string DECLARED_FZISO_AXLE4 = "Declared FzISO axle 4 [N]";
+ public const string ADAS_TECHNOLOGY_COMBINATION = "ADAS technology combination [-]";
+ public const string PTO_TECHNOLOGY = "PTOShaftsGearWheels";
+ //public const string PTO_OTHER_ELEMENTS = "PTOOtherElements";
+
+ public const string ENGINE_CERTIFICATION_NUMBER = "Engine certification number";
+ public const string AVERAGE_ENGINE_EFFICIENCY = "Average engine efficiency [%]";
+ public const string TORQUE_CONVERTER_CERTIFICATION_NUMBER = "TorqueConverter certification number";
+ public const string TORQUE_CONVERTER_CERTIFICATION_METHOD = "Torque converter certification option";
+ public const string AVERAGE_TORQUE_CONVERTER_EFFICIENCY_WITH_LOCKUP = "Average torque converter efficiency with lockup [%]";
+ public const string AVERAGE_TORQUE_CONVERTER_EFFICIENCY_WITHOUT_LOCKUP = "Average torque converter efficiency w/o lockup [%]";
+ public const string GEARBOX_CERTIFICATION_NUMBER = "Gearbox certification number";
+ public const string GEARBOX_CERTIFICATION_METHOD = "Gearbox certification option";
+ public const string AVERAGE_GEARBOX_EFFICIENCY = "Average gearbox efficiency [%]";
+ public const string RETARDER_CERTIFICATION_NUMBER = "Retarder certification number";
+ public const string RETARDER_CERTIFICATION_METHOD = "Retarder certification option";
+ public const string ANGLEDRIVE_CERTIFICATION_NUMBER = "Angledrive certification number";
+ public const string ANGLEDRIVE_CERTIFICATION_METHOD = "Angledrive certification option";
+ public const string AVERAGE_ANGLEDRIVE_EFFICIENCY = "Average angledrive efficiency [%]";
+ public const string AXLEGEAR_CERTIFICATION_NUMBER = "Axlegear certification number";
+ public const string AXLEGEAR_CERTIFICATION_METHOD = "Axlegear certification method";
+ public const string AVERAGE_AXLEGEAR_EFFICIENCY = "Average axlegear efficiency [%]";
+ public const string AIRDRAG_CERTIFICATION_NUMBER = "AirDrag certification number";
+ public const string AIRDRAG_CERTIFICATION_METHOD = "AirDrag certification option";
+
// ReSharper restore InconsistentNaming
internal readonly DataTable Table;
@@ -234,8 +270,19 @@ namespace TUGraz.VectoCore.OutputData
Tuple.Create(ENGINE_BF_COLD_HOT, typeof(double)),
Tuple.Create(ENGINE_CF_REG_PER, typeof(double)),
Tuple.Create(ENGINE_ACTUAL_CORRECTION_FACTOR, typeof(double)),
+ Tuple.Create(VEHICLE_FUEL_TYPE, typeof(string)),
+ Tuple.Create(AIRDRAG_MODEL, typeof(string)),
Tuple.Create(CD_x_A_DECLARED, typeof(ConvertedSI)),
Tuple.Create(CD_x_A, typeof(ConvertedSI)),
+ Tuple.Create(SLEEPER_CAB, typeof(string)),
+ Tuple.Create(DECLARED_RRC_AXLE1, typeof(double)),
+ Tuple.Create(DECLARED_FZISO_AXLE1, typeof(ConvertedSI)),
+ Tuple.Create(DECLARED_RRC_AXLE2, typeof(double)),
+ Tuple.Create(DECLARED_FZISO_AXLE2, typeof(ConvertedSI)),
+ Tuple.Create(DECLARED_RRC_AXLE3, typeof(double)),
+ Tuple.Create(DECLARED_FZISO_AXLE3, typeof(ConvertedSI)),
+ Tuple.Create(DECLARED_RRC_AXLE4, typeof(double)),
+ Tuple.Create(DECLARED_FZISO_AXLE4, typeof(ConvertedSI)),
Tuple.Create(ROLLING_RESISTANCE_COEFFICIENT_W_TRAILER, typeof(double)),
Tuple.Create(ROLLING_RESISTANCE_COEFFICIENT_WO_TRAILER, typeof(double)),
Tuple.Create(R_DYN, typeof(ConvertedSI)),
@@ -264,6 +311,9 @@ namespace TUGraz.VectoCore.OutputData
typeof(string)),
Tuple.Create(string.Format(AUX_TECH_FORMAT, Constants.Auxiliaries.IDs.PneumaticSystem), typeof(string)),
Tuple.Create(string.Format(AUX_TECH_FORMAT, Constants.Auxiliaries.IDs.ElectricSystem), typeof(string)),
+ Tuple.Create(ADAS_TECHNOLOGY_COMBINATION, typeof(string)),
+ Tuple.Create(PTO_TECHNOLOGY, typeof(string)),
+ //Tuple.Create(PTO_OTHER_ELEMENTS, typeof(string)),
}.Select(x => new DataColumn(x.Item1, x.Item2)).ToArray());
Table.Columns.AddRange(new[] {
@@ -286,6 +336,28 @@ namespace TUGraz.VectoCore.OutputData
MAX_SPEED, MAX_ACCELERATION, MAX_DECELERATION, AVG_ENGINE_SPEED, MAX_ENGINE_SPEED, NUM_GEARSHIFTS,
STOP_TIMESHARE, ENGINE_FULL_LOAD_TIME_SHARE, COASTING_TIME_SHARE, BRAKING_TIME_SHARE
}.Select(x => new DataColumn(x, typeof(ConvertedSI))).ToArray());
+
+ Table.Columns.AddRange(new[] {
+ Tuple.Create(ENGINE_CERTIFICATION_NUMBER, typeof(string)),
+ Tuple.Create(AVERAGE_ENGINE_EFFICIENCY, typeof(double)),
+ Tuple.Create(TORQUE_CONVERTER_CERTIFICATION_METHOD, typeof(string)),
+ Tuple.Create(TORQUE_CONVERTER_CERTIFICATION_NUMBER, typeof(string)),
+ Tuple.Create(AVERAGE_TORQUE_CONVERTER_EFFICIENCY_WITHOUT_LOCKUP, typeof(double)),
+ Tuple.Create(AVERAGE_TORQUE_CONVERTER_EFFICIENCY_WITH_LOCKUP, typeof(double)),
+ Tuple.Create(GEARBOX_CERTIFICATION_METHOD, typeof(string)),
+ Tuple.Create(GEARBOX_CERTIFICATION_NUMBER, typeof(string)),
+ Tuple.Create(AVERAGE_GEARBOX_EFFICIENCY, typeof(double)),
+ Tuple.Create(RETARDER_CERTIFICATION_METHOD, typeof(string)),
+ Tuple.Create(RETARDER_CERTIFICATION_NUMBER, typeof(string)),
+ Tuple.Create(ANGLEDRIVE_CERTIFICATION_METHOD, typeof(string)),
+ Tuple.Create(ANGLEDRIVE_CERTIFICATION_NUMBER, typeof(string)),
+ Tuple.Create(AVERAGE_ANGLEDRIVE_EFFICIENCY, typeof(double)),
+ Tuple.Create(AXLEGEAR_CERTIFICATION_METHOD, typeof(string)),
+ Tuple.Create(AXLEGEAR_CERTIFICATION_NUMBER, typeof(string)),
+ Tuple.Create(AVERAGE_AXLEGEAR_EFFICIENCY, typeof(double)),
+ Tuple.Create(AIRDRAG_CERTIFICATION_NUMBER, typeof(string)),
+ Tuple.Create(AIRDRAG_CERTIFICATION_METHOD, typeof(string)),
+ }.Select(x => new DataColumn(x.Item1, x.Item2)).ToArray());
}
/// <summary>
@@ -338,6 +410,7 @@ namespace TUGraz.VectoCore.OutputData
gearCount = (uint)runData.GearboxData.Gears.Count;
}
+ row[VEHICLE_FUEL_TYPE] = modData.FuelData.GetLabel();
var totalTime = modData.Duration();
row[TIME] = (ConvertedSI)totalTime;
@@ -375,7 +448,7 @@ namespace TUGraz.VectoCore.OutputData
WriteWorkEntries(modData, row, runData.Cycle.CycleType == CycleType.VTP);
- WritePerformanceEntries(modData, row);
+ WritePerformanceEntries(runData, modData, row);
row[ENGINE_FULL_LOAD_TIME_SHARE] = (ConvertedSI)modData.EngineMaxLoadTimeShare();
row[COASTING_TIME_SHARE] = (ConvertedSI)modData.CoastingTimeShare();
@@ -467,7 +540,7 @@ namespace TUGraz.VectoCore.OutputData
}
}
- private void WritePerformanceEntries(IModalDataContainer modData, DataRow row)
+ private void WritePerformanceEntries(VectoRunData runData, IModalDataContainer modData, DataRow row)
{
row[ACC] = (ConvertedSI)modData.AccelerationAverage();
row[ACC_POS] = (ConvertedSI)modData.AccelerationsPositive();
@@ -496,6 +569,50 @@ namespace TUGraz.VectoCore.OutputData
shareSum.ToOutputFormat(1, null, false));
}
}
+
+ var eFC = modData.TimeIntegral<Kilogram>(ModalResultField.FCFinal) * modData.FuelData.LowerHeatingValueVecto;
+ var eIcePos = modData.TimeIntegral<WattSecond>(ModalResultField.P_eng_fcmap, x => x > 0);
+ row[AVERAGE_ENGINE_EFFICIENCY] = (eIcePos / eFC).Value();
+
+ var gbxOutSignal = 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[AVERAGE_GEARBOX_EFFICIENCY] = (eGbxOut / eGbxIn).Value();
+
+ if (runData.GearboxData.Type.AutomaticTransmission()) {
+ var eTcIn = modData.TimeIntegral<WattSecond>(ModalResultField.P_TC_in, x => x > 0);
+ var eTcOut = eGbxIn;
+ row[AVERAGE_TORQUE_CONVERTER_EFFICIENCY_WITHOUT_LOCKUP] = (eTcOut / eTcIn).Value();
+
+ var tcData = modData.GetValues(
+ x => new {
+ dt = x.Field<Second>((int)ModalResultField.simulationInterval),
+ locked = x.Field<int>((int)ModalResultField.TC_Locked),
+ P_TCin = x.Field<Watt>((int)ModalResultField.P_TC_in),
+ P_TCout = x.Field<Watt>((int)ModalResultField.P_TC_out)
+ });
+ 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[AVERAGE_TORQUE_CONVERTER_EFFICIENCY_WITH_LOCKUP] = (eTcOut / eTcIn).Value();
+ }
+
+ if (runData.AngledriveData != null) {
+ var eAnglIn = modData.TimeIntegral<WattSecond>(ModalResultField.P_angle_in, x => x > 0);
+ var eAnglOut = modData.TimeIntegral<WattSecond>(ModalResultField.P_axle_in, x => x > 0);
+
+ row[AVERAGE_ANGLEDRIVE_EFFICIENCY] = (eAnglOut / eAnglIn).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[AVERAGE_AXLEGEAR_EFFICIENCY] = (eAxlOut / eAxlIn).Value();
}
private static void WriteWorkEntries(IModalDataContainer modData, DataRow row, bool vtpMode)
@@ -523,70 +640,126 @@ namespace TUGraz.VectoCore.OutputData
private void WriteFullPowertrain(VectoRunData runData, DataRow row)
{
- row[VEHICLE_MANUFACTURER] = runData.VehicleData.Manufacturer;
- row[VIN_NUMBER] = runData.VehicleData.VIN;
- row[VEHICLE_MODEL] = runData.VehicleData.ModelName;
-
- row[HDV_CO2_VEHICLE_CLASS] = runData.VehicleData.VehicleClass.GetClassNumber();
- row[CURB_MASS] = (ConvertedSI)runData.VehicleData.CurbWeight;
- // - (runData.VehicleData.BodyAndTrailerWeight ?? 0.SI<Kilogram>());
- row[LOADING] = (ConvertedSI)runData.VehicleData.Loading;
- row[CARGO_VOLUME] = (ConvertedSI)runData.VehicleData.CargoVolume;
-
- row[TOTAL_VEHICLE_MASS] = (ConvertedSI)runData.VehicleData.TotalVehicleWeight;
- row[ENGINE_MANUFACTURER] = runData.EngineData.Manufacturer;
- row[ENGINE_MODEL] = runData.EngineData.ModelName;
- row[ENGINE_FUEL_TYPE] = runData.EngineData.FuelData.GetLabel();
- row[ENGINE_RATED_POWER] = runData.EngineData.RatedPowerDeclared != null && runData.EngineData.RatedPowerDeclared > 0
- ? runData.EngineData.RatedPowerDeclared.ConvertToKiloWatt()
- : runData.EngineData.FullLoadCurves[0].MaxPower.ConvertToKiloWatt();
- row[ENGINE_IDLING_SPEED] = (ConvertedSI)runData.EngineData.IdleSpeed.AsRPM.SI<Scalar>();
- row[ENGINE_RATED_SPEED] = runData.EngineData.RatedSpeedDeclared != null && runData.EngineData.RatedSpeedDeclared > 0
- ? (ConvertedSI)runData.EngineData.RatedSpeedDeclared.AsRPM.SI<Scalar>()
- : (ConvertedSI)runData.EngineData.FullLoadCurves[0].RatedSpeed.AsRPM.SI<Scalar>();
- row[ENGINE_DISPLACEMENT] = runData.EngineData.Displacement.ConvertToCubicCentiMeter();
-
- row[ENGINE_WHTC_URBAN] = runData.EngineData.WHTCUrban;
- row[ENGINE_WHTC_RURAL] = runData.EngineData.WHTCRural;
- row[ENGINE_WHTC_MOTORWAY] = runData.EngineData.WHTCMotorway;
- row[ENGINE_BF_COLD_HOT] = runData.EngineData.ColdHotCorrectionFactor;
- row[ENGINE_CF_REG_PER] = runData.EngineData.CorrectionFactorRegPer;
- row[ENGINE_ACTUAL_CORRECTION_FACTOR] = runData.EngineData.FuelConsumptionCorrectionFactor;
-
- row[CD_x_A_DECLARED] = (ConvertedSI)runData.AirdragData.DeclaredAirdragArea;
- row[CD_x_A] = (ConvertedSI)runData.AirdragData.CrossWindCorrectionCurve.AirDragArea;
+ WriteVehicleData(runData.VehicleData, row);
+
+ row[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.Aux, row);
+
+ WriteAxleWheelsData(runData.VehicleData.AxleData, row);
+
+ WriteAirdragData(runData.AirdragData, row);
+
+ }
+
+ private static void WriteVehicleData(VehicleData data, DataRow row)
+ {
+ row[VEHICLE_MANUFACTURER] = data.Manufacturer;
+ row[VIN_NUMBER] = data.VIN;
+ row[VEHICLE_MODEL] = data.ModelName;
+
+ row[HDV_CO2_VEHICLE_CLASS] = data.VehicleClass.GetClassNumber();
+ row[CURB_MASS] = (ConvertedSI)data.CurbWeight;
+
+ // - (data.BodyAndTrailerWeight ?? 0.SI<Kilogram>());
+ row[LOADING] = (ConvertedSI)data.Loading;
+ row[CARGO_VOLUME] = (ConvertedSI)data.CargoVolume;
+
+ row[TOTAL_VEHICLE_MASS] = (ConvertedSI)data.TotalVehicleWeight;
+
+ row[SLEEPER_CAB] = data.SleeperCab ? "yes" : "no";
row[ROLLING_RESISTANCE_COEFFICIENT_WO_TRAILER] =
- runData.VehicleData.RollResistanceCoefficientWithoutTrailer;
+ data.RollResistanceCoefficientWithoutTrailer;
row[ROLLING_RESISTANCE_COEFFICIENT_W_TRAILER] =
- runData.VehicleData.TotalRollResistanceCoefficient;
+ data.TotalRollResistanceCoefficient;
- row[R_DYN] = (ConvertedSI)runData.VehicleData.DynamicTyreRadius;
+ row[R_DYN] = (ConvertedSI)data.DynamicTyreRadius;
- row[NUM_AXLES_DRIVEN] = runData.VehicleData.AxleData.Count(x => x.AxleType == AxleType.VehicleDriven);
- row[NUM_AXLES_NON_DRIVEN] = runData.VehicleData.AxleData.Count(x => x.AxleType == AxleType.VehicleNonDriven);
- row[NUM_AXLES_TRAILER] = runData.VehicleData.AxleData.Count(x => x.AxleType == AxleType.Trailer);
+ row[ADAS_TECHNOLOGY_COMBINATION] = DeclarationData.ADASCombinations.Lookup(data.ADAS).ID;
+ }
- row[GEARBOX_MANUFACTURER] = runData.GearboxData.Manufacturer;
- row[GEARBOX_MODEL] = runData.GearboxData.ModelName;
- row[GEARBOX_TYPE] = runData.GearboxData.Type;
- WriteGearboxData(runData, row);
+ private static void WriteAirdragData(AirdragData data, DataRow row)
+ {
+ row[AIRDRAG_MODEL] = data.ModelName;
+ row[AIRDRAG_CERTIFICATION_METHOD] = data.CertificationMethod.GetName();
+ row[AIRDRAG_CERTIFICATION_NUMBER] =
+ data.CertificationMethod == CertificationMethod.StandardValues ? "" : data.CertificationNumber;
+ row[CD_x_A_DECLARED] = (ConvertedSI)data.DeclaredAirdragArea;
+ row[CD_x_A] = (ConvertedSI)data.CrossWindCorrectionCurve.AirDragArea;
+ }
- row[RETARDER_TYPE] = runData.Retarder.Type.GetLabel();
- WriteRetarderData(runData, row);
+ private static void WriteEngineData(CombustionEngineData data, DataRow row)
+ {
+ row[ENGINE_MANUFACTURER] = data.Manufacturer;
+ row[ENGINE_MODEL] = data.ModelName;
+ row[ENGINE_CERTIFICATION_NUMBER] = data.CertificationNumber;
+ row[ENGINE_FUEL_TYPE] = data.FuelData.GetLabel();
+ row[ENGINE_RATED_POWER] = data.RatedPowerDeclared != null && data.RatedPowerDeclared > 0
+ ? data.RatedPowerDeclared.ConvertToKiloWatt()
+ : data.FullLoadCurves[0].MaxPower.ConvertToKiloWatt();
+ row[ENGINE_IDLING_SPEED] = (ConvertedSI)data.IdleSpeed.AsRPM.SI<Scalar>();
+ row[ENGINE_RATED_SPEED] = data.RatedSpeedDeclared != null && data.RatedSpeedDeclared > 0
+ ? (ConvertedSI)data.RatedSpeedDeclared.AsRPM.SI<Scalar>()
+ : (ConvertedSI)data.FullLoadCurves[0].RatedSpeed.AsRPM.SI<Scalar>();
+ row[ENGINE_DISPLACEMENT] = data.Displacement.ConvertToCubicCentiMeter();
+
+ row[ENGINE_WHTC_URBAN] = data.WHTCUrban;
+ row[ENGINE_WHTC_RURAL] = data.WHTCRural;
+ row[ENGINE_WHTC_MOTORWAY] = data.WHTCMotorway;
+ row[ENGINE_BF_COLD_HOT] = data.ColdHotCorrectionFactor;
+ row[ENGINE_CF_REG_PER] = data.CorrectionFactorRegPer;
+ row[ENGINE_ACTUAL_CORRECTION_FACTOR] = data.FuelConsumptionCorrectionFactor;
+ }
+
+ private static void WriteAxleWheelsData(List<Axle> data, DataRow row)
+ {
+ var fields = new[] {
+ Tuple.Create(DECLARED_RRC_AXLE1, DECLARED_FZISO_AXLE1),
+ Tuple.Create(DECLARED_RRC_AXLE2, DECLARED_FZISO_AXLE2),
+ Tuple.Create(DECLARED_RRC_AXLE3, DECLARED_FZISO_AXLE3),
+ Tuple.Create(DECLARED_RRC_AXLE4, 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;
+ }
- WriteAngledriveData(runData, row);
+ row[NUM_AXLES_DRIVEN] = data.Count(x => x.AxleType == AxleType.VehicleDriven);
+ row[NUM_AXLES_NON_DRIVEN] = data.Count(x => x.AxleType == AxleType.VehicleNonDriven);
+ row[NUM_AXLES_TRAILER] = data.Count(x => x.AxleType == AxleType.Trailer);
- row[AXLE_MANUFACTURER] = runData.AxleGearData.Manufacturer;
- row[AXLE_MODEL] = runData.AxleGearData.ModelName;
- row[AXLE_RATIO] = (ConvertedSI)runData.AxleGearData.AxleGear.Ratio.SI<Scalar>();
+ }
- WriteAuxTechnologies(runData, row);
+ private static void WriteAxlegearData(AxleGearData data, DataRow row)
+ {
+ row[AXLE_MANUFACTURER] = data.Manufacturer;
+ row[AXLE_MODEL] = data.ModelName;
+ row[AXLE_RATIO] = (ConvertedSI)data.AxleGear.Ratio.SI<Scalar>();
+ row[AXLEGEAR_CERTIFICATION_METHOD] = data.CertificationMethod.GetName();
+ row[AXLEGEAR_CERTIFICATION_NUMBER] = data.CertificationMethod == CertificationMethod.StandardValues
+ ? ""
+ : data.CertificationNumber;
}
- private void WriteAuxTechnologies(VectoRunData runData, DataRow row)
+ private void WriteAuxTechnologies(IEnumerable<VectoRunData.AuxData> auxData, DataRow row)
{
- foreach (var aux in runData.Aux) {
+ foreach (var aux in auxData) {
if (aux.ID == Constants.Auxiliaries.IDs.PTOConsumer || aux.ID == Constants.Auxiliaries.IDs.PTOTransmission) {
continue;
}
@@ -602,52 +775,80 @@ namespace TUGraz.VectoCore.OutputData
}
}
- private static void WriteAngledriveData(VectoRunData runData, DataRow row)
+ private static void WriteAngledriveData(AngledriveData data, DataRow row)
{
- if (runData.AngledriveData != null) {
- row[ANGLEDRIVE_MANUFACTURER] = runData.AngledriveData.Manufacturer;
- row[ANGLEDRIVE_MODEL] = runData.AngledriveData.ModelName;
- row[ANGLEDRIVE_RATIO] = runData.AngledriveData.Angledrive.Ratio;
+ if (data != null) {
+ row[ANGLEDRIVE_MANUFACTURER] = data.Manufacturer;
+ row[ANGLEDRIVE_MODEL] = data.ModelName;
+ row[ANGLEDRIVE_RATIO] = data.Angledrive.Ratio;
+ row[ANGLEDRIVE_CERTIFICATION_METHOD] = data.CertificationMethod.GetName();
+ row[ANGLEDRIVE_CERTIFICATION_NUMBER] =
+ data.CertificationMethod == CertificationMethod.StandardValues
+ ? ""
+ : data.CertificationNumber;
} else {
row[ANGLEDRIVE_MANUFACTURER] = "n.a.";
row[ANGLEDRIVE_MODEL] = "n.a.";
row[ANGLEDRIVE_RATIO] = "n.a.";
+ row[ANGLEDRIVE_CERTIFICATION_METHOD] = "";
}
}
- private static void WriteRetarderData(VectoRunData runData, DataRow row)
+ private static void WriteRetarderData(RetarderData data, DataRow row)
{
- if (runData.Retarder.Type.IsDedicatedComponent()) {
- row[RETARDER_MANUFACTURER] = runData.Retarder.Manufacturer;
- row[RETARDER_MODEL] = runData.Retarder.ModelName;
+ row[RETARDER_TYPE] = data.Type.GetLabel();
+ if (data.Type.IsDedicatedComponent()) {
+ row[RETARDER_MANUFACTURER] = data.Manufacturer;
+ row[RETARDER_MODEL] = data.ModelName;
+ row[RETARDER_CERTIFICATION_METHOD] = data.CertificationMethod.GetName();
+ row[RETARDER_CERTIFICATION_NUMBER] = data.CertificationMethod == CertificationMethod.StandardValues
+ ? ""
+ : data.CertificationNumber;
} else {
row[RETARDER_MANUFACTURER] = "n.a.";
row[RETARDER_MODEL] = "n.a.";
+ row[RETARDER_CERTIFICATION_METHOD] = "";
+ row[RETARDER_CERTIFICATION_NUMBER] = "";
}
}
- private static void WriteGearboxData(VectoRunData runData, DataRow row)
+ private static void WriteGearboxData(GearboxData data, DataRow row)
{
- if (runData.GearboxData.Type.AutomaticTransmission()) {
- row[GEAR_RATIO_FIRST_GEAR] = runData.GearboxData.Gears.Count > 0
- ? (double.IsNaN(runData.GearboxData.Gears.First().Value.Ratio)
- ? (ConvertedSI)runData.GearboxData.Gears.First().Value.TorqueConverterRatio.SI<Scalar>()
- : (ConvertedSI)runData.GearboxData.Gears.First().Value.Ratio.SI<Scalar>())
+ row[GEARBOX_MANUFACTURER] = data.Manufacturer;
+ row[GEARBOX_MODEL] = data.ModelName;
+ row[GEARBOX_TYPE] = data.Type;
+ row[GEARBOX_CERTIFICATION_NUMBER] = data.CertificationMethod == CertificationMethod.StandardValues
+ ? ""
+ : data.CertificationNumber;
+ row[GEARBOX_CERTIFICATION_METHOD] = data.CertificationMethod.GetName();
+ if (data.Type.AutomaticTransmission()) {
+ row[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[GEAR_RATIO_LAST_GEAR] = runData.GearboxData.Gears.Count > 0
- ? (ConvertedSI)runData.GearboxData.Gears.Last().Value.Ratio.SI<Scalar>()
+ row[GEAR_RATIO_LAST_GEAR] = data.Gears.Count > 0
+ ? (ConvertedSI)data.Gears.Last().Value.Ratio.SI<Scalar>()
: (ConvertedSI)0.SI<Scalar>();
- row[TORQUECONVERTER_MANUFACTURER] = runData.GearboxData.TorqueConverterData.Manufacturer;
- row[TORQUECONVERTER_MODEL] = runData.GearboxData.TorqueConverterData.ModelName;
+ row[TORQUECONVERTER_MANUFACTURER] = data.TorqueConverterData.Manufacturer;
+ row[TORQUECONVERTER_MODEL] = data.TorqueConverterData.ModelName;
+ row[TORQUE_CONVERTER_CERTIFICATION_NUMBER] =
+ data.TorqueConverterData.CertificationMethod == CertificationMethod.StandardValues
+ ? ""
+ : data.TorqueConverterData.CertificationNumber;
+ row[TORQUE_CONVERTER_CERTIFICATION_METHOD] = data.TorqueConverterData.CertificationMethod.GetName();
+
} else {
- row[GEAR_RATIO_FIRST_GEAR] = runData.GearboxData.Gears.Count > 0
- ? (ConvertedSI)runData.GearboxData.Gears.First().Value.Ratio.SI<Scalar>()
+ row[GEAR_RATIO_FIRST_GEAR] = data.Gears.Count > 0
+ ? (ConvertedSI)data.Gears.First().Value.Ratio.SI<Scalar>()
: (ConvertedSI)0.SI<Scalar>();
- row[GEAR_RATIO_LAST_GEAR] = runData.GearboxData.Gears.Count > 0
- ? (ConvertedSI)runData.GearboxData.Gears.Last().Value.Ratio.SI<Scalar>()
+ row[GEAR_RATIO_LAST_GEAR] = data.Gears.Count > 0
+ ? (ConvertedSI)data.Gears.Last().Value.Ratio.SI<Scalar>()
: (ConvertedSI)0.SI<Scalar>();
row[TORQUECONVERTER_MANUFACTURER] = "n.a.";
row[TORQUECONVERTER_MODEL] = "n.a.";
+ row[TORQUE_CONVERTER_CERTIFICATION_METHOD] = "";
+ row[TORQUE_CONVERTER_CERTIFICATION_NUMBER] = "";
}
}
diff --git a/VectoCore/VectoCore/OutputData/XML/XMLCustomerReport.cs b/VectoCore/VectoCore/OutputData/XML/XMLCustomerReport.cs
index 2bdcf957fb..d3cc68d1c3 100644
--- a/VectoCore/VectoCore/OutputData/XML/XMLCustomerReport.cs
+++ b/VectoCore/VectoCore/OutputData/XML/XMLCustomerReport.cs
@@ -120,7 +120,7 @@ namespace TUGraz.VectoCore.OutputData.XML
{
return new XElement(tns + XMLNames.Vehicle_ADAS,
new XElement(tns + XMLNames.Vehicle_ADAS_EngineStopStart, adasData.EngineStopStart),
- new XElement(tns + XMLNames.Vehicle_ADAS_EcoRollWithoutEngineStop, adasData.EcoRollWithoutengineStop),
+ new XElement(tns + XMLNames.Vehicle_ADAS_EcoRollWithoutEngineStop, adasData.EcoRollWithoutEngineStop),
new XElement(tns + XMLNames.Vehicle_ADAS_EcoRollWithEngineStopStart, adasData.EcoRollWithEngineStop),
new XElement(tns + XMLNames.Vehicle_ADAS_PCC, adasData.PredictiveCruiseControl != PredictiveCruiseControlType.None)
);
diff --git a/VectoCore/VectoCore/OutputData/XML/XMLManufacturerReport.cs b/VectoCore/VectoCore/OutputData/XML/XMLManufacturerReport.cs
index 973f1da958..1f7f252fdb 100644
--- a/VectoCore/VectoCore/OutputData/XML/XMLManufacturerReport.cs
+++ b/VectoCore/VectoCore/OutputData/XML/XMLManufacturerReport.cs
@@ -112,7 +112,7 @@ namespace TUGraz.VectoCore.OutputData.XML
{
return new XElement(tns + XMLNames.Vehicle_ADAS,
new XElement(tns + XMLNames.Vehicle_ADAS_EngineStopStart, adasData.EngineStopStart),
- new XElement(tns + XMLNames.Vehicle_ADAS_EcoRollWithoutEngineStop, adasData.EcoRollWithoutengineStop),
+ new XElement(tns + XMLNames.Vehicle_ADAS_EcoRollWithoutEngineStop, adasData.EcoRollWithoutEngineStop),
new XElement(tns + XMLNames.Vehicle_ADAS_EcoRollWithEngineStopStart, adasData.EcoRollWithEngineStop),
new XElement(tns + XMLNames.Vehicle_ADAS_PCC, adasData.PredictiveCruiseControl != PredictiveCruiseControlType.None)
);
--
GitLab