From a4b3f7f47dd3bb24ca66f3b4ba9c9e0cdf71b213 Mon Sep 17 00:00:00 2001
From: Markus Quaritsch <quaritsch@ivt.tugraz.at>
Date: Fri, 16 Dec 2022 09:35:36 +0100
Subject: [PATCH] adding results writer for VIF more testcases, minor
refactoring
---
.../VectoCore/Ninject/VectoNinjectModule.cs | 10 +-
.../Common/ElectricEnergyWriter.cs | 8 +-
.../Common/FuelConsumptionWriter.cs | 8 +-
.../Common/IInternalResultWriterFactory.cs | 3 +
.../Common/IResultsWriter.cs | 1 +
.../Common/IResultsWriterFactory.cs | 3 +
.../Common/ResultGroupWriter.cs | 28 ++-
.../Common/ResultWriterFactory.cs | 12 +
.../Common/ResultsNinjectModule.cs | 5 +-
.../CIFResultsNinjectModule.cs | 3 +
.../MRFResultsNinjectModule.cs | 3 +
...MRFResultWriter.cs => MRFResultsWriter.cs} | 0
.../ResultWriter/IVIFResultsWriterFactory.cs | 6 +
.../ResultWriter/ResultGroupWriter.cs | 229 ++++++++++++++++++
.../ResultWriter/ResultWriter.cs | 145 +++++++++++
.../ResultWriter/VIFResultsWriter.cs | 103 ++++++++
.../VIFResultsNinjectModule.cs | 106 ++++++++
VectoCore/VectoCore/VectoCore.csproj | 1 +
.../Reports/TestXMLResultsWriting.cs | 101 +++++++-
19 files changed, 754 insertions(+), 21 deletions(-)
rename VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ResultWriter/{MRFResultWriter.cs => MRFResultsWriter.cs} (100%)
create mode 100644 VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/ResultWriter/IVIFResultsWriterFactory.cs
create mode 100644 VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/ResultWriter/ResultGroupWriter.cs
create mode 100644 VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/ResultWriter/ResultWriter.cs
create mode 100644 VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/ResultWriter/VIFResultsWriter.cs
create mode 100644 VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/VIFResultsNinjectModule.cs
diff --git a/VectoCore/VectoCore/Ninject/VectoNinjectModule.cs b/VectoCore/VectoCore/Ninject/VectoNinjectModule.cs
index c3934a0ef1..b2480b3635 100644
--- a/VectoCore/VectoCore/Ninject/VectoNinjectModule.cs
+++ b/VectoCore/VectoCore/Ninject/VectoNinjectModule.cs
@@ -108,8 +108,10 @@ namespace TUGraz.VectoCore
LoadModule<VIFNinjectModule>();
+ LoadModule<VIFResultsNinjectModule>();
-#if (MOCKUP)
+
+#if (MOCKUP)
var compiledModuleLoaderPlugin = new CompiledModuleLoaderPlugin(Kernel, new AssemblyNameRetriever());
var assembly = Assembly.LoadFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),"VectoMockup.dll"));
//var assembly = Assembly.LoadFile("VectoMockup.dll");
@@ -122,10 +124,10 @@ namespace TUGraz.VectoCore
}
-
-#endregion
-
+ #endregion
+
+
}
}
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/ElectricEnergyWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/ElectricEnergyWriter.cs
index 809cfdb831..4113d601ca 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/ElectricEnergyWriter.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/ElectricEnergyWriter.cs
@@ -18,7 +18,7 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.Common
public virtual XElement GetElement(IResultEntry entry)
{
- return new XElement(TNS + "ElectricEnergy",
+ return new XElement(TNS + ElectricEnergyConsumptionXMLElementName,
GetEnergyConsumption(entry.ElectricEnergyConsumption, entry.Distance, entry.Payload, entry.CargoVolume,
entry.PassengerCount).Select(x =>
new XElement(TNS + XMLNames.Report_Result_EnergyConsumption, x.ValueAsUnit(3, 1)))
@@ -27,7 +27,7 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.Common
public virtual XElement GetElement(IWeightedResult weighted)
{
- return new XElement(TNS + "ElectricEnergy",
+ return new XElement(TNS + ElectricEnergyConsumptionXMLElementName,
GetEnergyConsumption(weighted.ElectricEnergyConsumption, weighted.Distance, weighted.Payload, weighted.CargoVolume,
weighted.PassengerCount).Select(x =>
new XElement(TNS + XMLNames.Report_Result_EnergyConsumption, x.ValueAsUnit(3, 1)))
@@ -39,7 +39,9 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.Common
Kilogram payload, CubicMeter volume, double? passengers);
#endregion
- }
+
+ protected virtual string ElectricEnergyConsumptionXMLElementName => "ElectricEnergy";
+ }
public class LorryElectricEnergyConsumptionWriter : ElectricEnergyConsumptionWriterBase
{
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/FuelConsumptionWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/FuelConsumptionWriter.cs
index 3b5b624b46..547beae36e 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/FuelConsumptionWriter.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/FuelConsumptionWriter.cs
@@ -33,12 +33,12 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.Common
);
}
- protected abstract IList<ConvertedSI> GetFuelConsumptionEntries(Kilogram fc,
- IFuelProperties fuel, Meter distance, Kilogram payload, CubicMeter volume,
- double? passenger);
-
#endregion
+ protected abstract IList<ConvertedSI> GetFuelConsumptionEntries(Kilogram fc,
+ IFuelProperties fuel, Meter distance, Kilogram payload, CubicMeter volume,
+ double? passenger);
+
}
public class LorryFuelConsumptionWriter : FuelConsumptionWriterBase
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/IInternalResultWriterFactory.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/IInternalResultWriterFactory.cs
index a1e02ed869..7aef9181b1 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/IInternalResultWriterFactory.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/IInternalResultWriterFactory.cs
@@ -10,5 +10,8 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.Common
IResultsWriter GetMRFResultsWriter(
VehicleTypeAndArchitectureStringHelperResults.ResultsVehicleClassification vehicleClasiClassification);
+ IResultsWriter GetVIFResultsWriter(
+ VehicleTypeAndArchitectureStringHelperResults.ResultsVehicleClassification vehicleClasiClassification);
+
}
}
\ No newline at end of file
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/IResultsWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/IResultsWriter.cs
index fa9fcf98e3..8c1be5c413 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/IResultsWriter.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/IResultsWriter.cs
@@ -89,6 +89,7 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.Common
IResultSequenceWriter GetSuccessMissionWriter(ICommonResultsWriterFactory factory, XNamespace ns);
IResultSequenceWriter GetErrorMissionWriter(ICommonResultsWriterFactory factory, XNamespace ns);
IResultGroupWriter GetLorrySimulationParameterWriter(ICommonResultsWriterFactory factory, XNamespace ns);
+ IResultGroupWriter GetErrorSimulationParameterWriter(ICommonResultsWriterFactory factory, XNamespace ns);
IResultGroupWriter GetLorryConvTotalWriter(ICommonResultsWriterFactory factory, XNamespace ns);
IResultGroupWriter GetLorryHEVNonOVCTotalWriter(ICommonResultsWriterFactory factory, XNamespace ns);
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/IResultsWriterFactory.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/IResultsWriterFactory.cs
index 04f7c9db5d..5541fa5b91 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/IResultsWriterFactory.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/IResultsWriterFactory.cs
@@ -10,5 +10,8 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.Common
IResultsWriter GetMRFResultsWriter(string vehicleCategory, VectoSimulationJobType jobType, bool ovc,
bool exempted);
+ IResultsWriter GetVIFResultsWriter(string vehicleCategory, VectoSimulationJobType jobType, bool ovc,
+ bool exempted);
+
}
}
\ No newline at end of file
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/ResultGroupWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/ResultGroupWriter.cs
index 8e39e7e081..18703255bc 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/ResultGroupWriter.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/ResultGroupWriter.cs
@@ -67,6 +67,24 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.Common
#endregion
}
+ public class ResultSimulationParameterErrorWriter : AbstractResultGroupWriter
+ {
+ public ResultSimulationParameterErrorWriter(ICommonResultsWriterFactory factory, XNamespace ns) : base(factory, ns) { }
+
+ #region Overrides of AbstractResultWriter
+
+ public override XElement GetElement(IResultEntry entry)
+ {
+ return new XElement(TNS + XMLNames.Report_ResultEntry_SimulationParameters,
+ new XElement(TNS + XMLNames.Report_ResultEntry_TotalVehicleMass,
+ XMLHelper.ValueAsUnit(entry.TotalVehicleMass, XMLNames.Unit_kg)),
+ new XElement(TNS + XMLNames.Report_ResultEntry_Payload,
+ XMLHelper.ValueAsUnit(entry.Payload, XMLNames.Unit_kg)));
+ }
+
+ #endregion
+ }
+
public class ElectricRangeWriter : AbstractResultWriter, IElectricRangeWriter
{
public ElectricRangeWriter(ICommonResultsWriterFactory factory, XNamespace ns) : base(factory, ns) { }
@@ -115,9 +133,9 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.Common
return new XElement(TNS + XMLNames.Report_Result_Result,
new XAttribute(XMLNames.Report_Result_Status_Attr, "error"),
- new XAttribute(xsi + "type", "ResultErrorType"),
+ ResultXMLType != null ? new XAttribute(xsi + "type", ResultXMLType) : null,
_factory.GetErrorMissionWriter(_factory, TNS).GetElement(entry),
- _factory.GetLorrySimulationParameterWriter(_factory, TNS).GetElement(entry),
+ _factory.GetErrorSimulationParameterWriter(_factory, TNS).GetElement(entry),
_factory.GetErrorDetailsWriter(_factory, TNS).GetElement(entry)
);
}
@@ -130,13 +148,15 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.Common
}
return new XElement(TNS + XMLNames.Report_Result_Result,
new XAttribute(XMLNames.Report_Result_Status_Attr, "error"),
- new XAttribute(xsi + "type", "ResultErrorType"),
+ ResultXMLType != null ? new XAttribute(xsi + "type", ResultXMLType) : null,
_factory.GetErrorMissionWriter(_factory, TNS).GetElement(errorEntry),
- _factory.GetLorrySimulationParameterWriter(_factory, TNS).GetElement(errorEntry),
+ _factory.GetErrorSimulationParameterWriter(_factory, TNS).GetElement(errorEntry),
_factory.GetErrorDetailsWriter(_factory, TNS).GetElement(errorEntry)
);
}
#endregion
+
+ protected virtual string ResultXMLType => "ResultErrorType";
}
}
\ No newline at end of file
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/ResultWriterFactory.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/ResultWriterFactory.cs
index 3b753e4e78..44397115ff 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/ResultWriterFactory.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/ResultWriterFactory.cs
@@ -40,6 +40,18 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.Common
}
}
+ public IResultsWriter GetVIFResultsWriter(string vehicleCategory, VectoSimulationJobType jobType, bool ovc, bool exempted)
+ {
+ try {
+ return _internalFactory.GetVIFResultsWriter(
+ new VehicleTypeAndArchitectureStringHelperResults.ResultsVehicleClassification(
+ XmlDocumentType.MultistepOutputData, vehicleCategory,
+ jobType.GetPowertrainArchitectureType(), ovc, exempted));
+ } catch (Exception e) {
+ throw new Exception($"Could not create ResultsWriter for vehicle category {vehicleCategory}, {jobType}, ovc: {ovc}, exempted: {exempted}", e);
+ }
+ }
+
#endregion
}
}
\ No newline at end of file
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/ResultsNinjectModule.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/ResultsNinjectModule.cs
index 74850fa24d..2ec47d8781 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/ResultsNinjectModule.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/Common/ResultsNinjectModule.cs
@@ -25,7 +25,10 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.Common
typeof(IInternalResultWriterFactory).GetMethod(nameof(IInternalResultWriterFactory
.GetCIFResultsWriter)),
typeof(IInternalResultWriterFactory).GetMethod(nameof(IInternalResultWriterFactory
- .GetMRFResultsWriter))
+ .GetMRFResultsWriter)),
+ typeof(IInternalResultWriterFactory).GetMethod(nameof(IInternalResultWriterFactory
+ .GetVIFResultsWriter))
+
}
})).InSingletonScope();
}
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFResultsNinjectModule.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFResultsNinjectModule.cs
index 630d288562..da90cf8a5a 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFResultsNinjectModule.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFResultsNinjectModule.cs
@@ -71,6 +71,9 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation
Bind<IResultGroupWriter>().To<ResultSimulationParameterLorryWriter>().When(AccessedViaCIFResultsWriterFactory)
.NamedLikeFactoryMethod((ICIFResultsWriterFactory c) => c.GetLorrySimulationParameterWriter(null, XNamespace.None));
+ Bind<IResultGroupWriter>().To<ResultSimulationParameterLorryWriter>().When(AccessedViaCIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((ICIFResultsWriterFactory c) => c.GetErrorSimulationParameterWriter(null, XNamespace.None));
+
Bind<IResultGroupWriter>().To<LorryConvTotalWriter>().When(AccessedViaCIFResultsWriterFactory)
.NamedLikeFactoryMethod((ICIFResultsWriterFactory c) => c.GetLorryConvTotalWriter(null, XNamespace.None));
Bind<IResultGroupWriter>().To<LorryHEVNonOVCTotalWriter>().When(AccessedViaCIFResultsWriterFactory)
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/MRFResultsNinjectModule.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/MRFResultsNinjectModule.cs
index d5d909ab6b..ae25772560 100644
--- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/MRFResultsNinjectModule.cs
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/MRFResultsNinjectModule.cs
@@ -71,6 +71,9 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation
Bind<IResultGroupWriter>().To<ResultSimulationParameterLorryWriter>().When(AccessedViaMRFResultsWriterFactory)
.NamedLikeFactoryMethod((IMRFResultsWriterFactory c) => c.GetLorrySimulationParameterWriter(null, XNamespace.None));
+ Bind<IResultGroupWriter>().To<ResultSimulationParameterErrorWriter>().When(AccessedViaMRFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IMRFResultsWriterFactory c) => c.GetErrorSimulationParameterWriter(null, XNamespace.None));
+
Bind<IResultGroupWriter>().To<LorryConvTotalWriter>().When(AccessedViaMRFResultsWriterFactory)
.NamedLikeFactoryMethod((IMRFResultsWriterFactory c) => c.GetLorryConvTotalWriter(null, XNamespace.None));
Bind<IResultGroupWriter>().To<LorryHEVNonOVCTotalWriter>().When(AccessedViaMRFResultsWriterFactory)
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ResultWriter/MRFResultWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ResultWriter/MRFResultsWriter.cs
similarity index 100%
rename from VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ResultWriter/MRFResultWriter.cs
rename to VectoCore/VectoCore/OutputData/XML/DeclarationReports/ManufacturerReport/ManufacturerReport_0_9/ResultWriter/MRFResultsWriter.cs
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/ResultWriter/IVIFResultsWriterFactory.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/ResultWriter/IVIFResultsWriterFactory.cs
new file mode 100644
index 0000000000..c77632fd47
--- /dev/null
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/ResultWriter/IVIFResultsWriterFactory.cs
@@ -0,0 +1,6 @@
+using TUGraz.VectoCore.OutputData.XML.DeclarationReports.Common;
+
+namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.VehicleInformationFile.VehicleInformationFile_0_1.ResultWriter
+{
+ public interface IVIFResultsWriterFactory : ICommonResultsWriterFactory { }
+}
\ No newline at end of file
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/ResultWriter/ResultGroupWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/ResultWriter/ResultGroupWriter.cs
new file mode 100644
index 0000000000..84275be7fe
--- /dev/null
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/ResultWriter/ResultGroupWriter.cs
@@ -0,0 +1,229 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+using TUGraz.VectoCommon.BusAuxiliaries;
+using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCommon.Resources;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.Models.Declaration;
+using TUGraz.VectoCore.OutputData.XML.DeclarationReports.Common;
+using TUGraz.VectoCore.Utils;
+
+namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.VehicleInformationFile.VehicleInformationFile_0_1.ResultWriter
+{
+ public class VIFErrorResultWriter : ErrorResultWriter
+ {
+ public VIFErrorResultWriter(ICommonResultsWriterFactory factory, XNamespace ns) : base(factory, ns) { }
+
+ #region Overrides of ErrorResultWriter
+
+ protected override string ResultXMLType => null;
+
+ #endregion
+ }
+
+ public class ResultSimulationParameterVIFBusWriter : AbstractResultGroupWriter
+ {
+ public ResultSimulationParameterVIFBusWriter(ICommonResultsWriterFactory factory, XNamespace ns) : base(factory, ns) { }
+
+ #region Overrides of AbstractResultWriter
+
+ public override XElement GetElement(IResultEntry entry)
+ {
+ return new XElement(TNS + XMLNames.Report_ResultEntry_SimulationParameters,
+ new XElement(TNS + XMLNames.Report_ResultEntry_TotalVehicleMass,
+ entry.TotalVehicleMass.ValueAsUnit(XMLNames.Unit_kg)),
+ new XElement(TNS + XMLNames.Report_Result_Payload,
+ entry.Payload.ValueAsUnit(XMLNames.Unit_kg)),
+ new XElement(TNS + XMLNames.Report_Result_PassengerCount,
+ (entry.PassengerCount ?? double.NaN).ToXMLFormat(2))
+ );
+ }
+
+ #endregion
+ }
+
+ public class VIFResultErrorMissionWriter : AbstractResultWriter, IResultSequenceWriter
+ {
+ public VIFResultErrorMissionWriter(ICommonResultsWriterFactory factory, XNamespace ns) : base(factory, ns) { }
+
+ #region Overrides of AbstractResultWriter
+
+ public virtual XElement[] GetElement(IResultEntry entry)
+ {
+ return new[] {
+ new XElement(TNS + XMLNames.Report_Results_PrimaryVehicleSubgroup, entry.VehicleClass.ToXML()),
+ new XElement(TNS + XMLNames.Report_Result_Mission, entry.Mission.ToXMLFormat())
+ };
+ }
+
+ public XElement[] GetElement(IOVCResultEntry entry)
+ {
+ return null;
+ }
+
+ #endregion
+ }
+
+ public class VIFResultSimulationParameterErrorWriter : AbstractResultGroupWriter
+ {
+ public VIFResultSimulationParameterErrorWriter(ICommonResultsWriterFactory factory, XNamespace ns) : base(factory, ns) { }
+
+ #region Overrides of AbstractResultWriter
+
+ public override XElement GetElement(IResultEntry entry)
+ {
+ return new XElement(TNS + XMLNames.Report_ResultEntry_SimulationParameters,
+ new XElement(TNS + XMLNames.Report_ResultEntry_TotalVehicleMass,
+ XMLHelper.ValueAsUnit(entry.TotalVehicleMass, XMLNames.Unit_kg)),
+ new XElement(TNS + XMLNames.Report_ResultEntry_Payload,
+ XMLHelper.ValueAsUnit(entry.Payload, XMLNames.Unit_kg)),
+ new XElement(TNS + XMLNames.Report_ResultEntry_PassengerCount,
+ entry.PassengerCount?.ToXMLFormat(2) ?? "NaN")
+ );
+ }
+
+ #endregion
+ }
+
+
+ public class VehiclePerformanceVIFWriter : AbstractResultGroupWriter
+ {
+ public VehiclePerformanceVIFWriter(ICommonResultsWriterFactory factory, XNamespace ns) : base(factory, ns) { }
+
+ #region Overrides of AbstractResultGroupWriter
+
+ public override XElement GetElement(IResultEntry entry)
+ {
+ return null;
+ }
+
+ public override XElement GetElement(IOVCResultEntry entry)
+ {
+ return null;
+ }
+
+ #endregion
+ }
+
+ public class VIFFuelConsumptionWriter : AbstractResultWriter, IFuelConsumptionWriter
+ {
+ public VIFFuelConsumptionWriter(ICommonResultsWriterFactory factory, XNamespace ns) : base(factory, ns) { }
+
+
+ #region Implementation of IFuelConsumptionWriter
+
+ public XElement GetElement(IResultEntry entry, IFuelConsumptionCorrection fc)
+ {
+ return new XElement(TNS + XMLNames.Report_Results_Fuel,
+ new XAttribute(XMLNames.Report_Results_Fuel_Type_Attr, fc.Fuel.FuelType.ToXMLFormat()),
+ GetFuelConsumptionEntries(fc.TotalFuelConsumptionCorrected, fc.Fuel, entry.Distance, entry.Payload,
+ entry.CargoVolume, entry.PassengerCount).Select(x =>
+ new XElement(TNS + XMLNames.Report_Result_EnergyConsumption, x.ValueAsUnit(3, 1)))
+ );
+ }
+
+ public XElement GetElement(IWeightedResult entry, IFuelProperties fuel, Kilogram consumption)
+ {
+ return new XElement(TNS + XMLNames.Report_Results_Fuel,
+ new XAttribute(XMLNames.Report_Results_Fuel_Type_Attr, fuel.FuelType.ToXMLFormat()),
+ GetFuelConsumptionEntries(consumption, fuel, entry.Distance, entry.Payload, entry.CargoVolume,
+ entry.PassengerCount).Select(x =>
+ new XElement(TNS + XMLNames.Report_Result_EnergyConsumption, x.ValueAsUnit(3, 1)))
+ );
+ }
+
+ #endregion
+
+ protected virtual IList<ConvertedSI> GetFuelConsumptionEntries(Kilogram fc, IFuelProperties fuel,
+ Meter distance, Kilogram payload, CubicMeter volume, double? passenger)
+ {
+ return new List<ConvertedSI> {
+ (fc * fuel.LowerHeatingValueVecto / distance).ConvertToMegaJoulePerKilometer(),
+ };
+ }
+
+ }
+
+ public class VIFElectricEnergyConsumptionWriter : ElectricEnergyConsumptionWriterBase
+ {
+ public VIFElectricEnergyConsumptionWriter(ICommonResultsWriterFactory factory, XNamespace ns) : base(factory, ns) { }
+
+ #region Overrides of ElectricEnergyConsumptionWriterBase
+
+ protected override string ElectricEnergyConsumptionXMLElementName => "ElectricEnergyConsumption";
+
+
+ protected override IList<ConvertedSI> GetEnergyConsumption(WattSecond elEnergy, Meter distance,
+ Kilogram payload, CubicMeter volume, double? passengers)
+ {
+ return new[] {
+ (elEnergy / distance).ConvertToMegaJoulePerKiloMeter(),
+ };
+ }
+
+ #endregion
+ }
+
+ public class VIFCO2Writer : ICO2Writer
+ {
+ #region Implementation of ICO2Writer
+
+ public XElement[] GetElements(IResultEntry entry)
+ {
+ return null;
+ }
+
+ public XElement[] GetElements(IWeightedResult entry)
+ {
+ return null;
+ }
+
+ #endregion
+ }
+
+ public class VIFResultSuccessMissionWriter : AbstractResultWriter, IResultSequenceWriter
+ {
+ public VIFResultSuccessMissionWriter(ICommonResultsWriterFactory factory, XNamespace ns) : base(factory, ns) { }
+
+ #region Overrides of AbstractResultWriter
+
+ public virtual XElement[] GetElement(IResultEntry entry)
+ {
+ return new[] {
+ new XElement(TNS + XMLNames.Report_Results_PrimaryVehicleSubgroup, entry.VehicleClass.ToXML()),
+ new XElement(TNS + XMLNames.Report_Result_Mission, entry.Mission.ToXMLFormat())
+ };
+ }
+
+ public XElement[] GetElement(IOVCResultEntry entry)
+ {
+ return null;
+ }
+
+ #endregion
+ }
+
+ public class VIFErrorDetailsWriter : AbstractResultWriter, IResultSequenceWriter
+ {
+ public VIFErrorDetailsWriter(ICommonResultsWriterFactory factory, XNamespace ns) : base(factory, ns) { }
+
+ #region Implementation of IResultSequenceWriter
+
+ public XElement[] GetElement(IResultEntry entry)
+ {
+ return new[] {
+ new XElement(TNS + XMLNames.Report_Results_Error, entry.Error),
+ new XElement(TNS + XMLNames.Report_Results_ErrorDetails, entry.StackTrace)
+ };
+ }
+
+ public XElement[] GetElement(IOVCResultEntry entry)
+ {
+ throw new NotImplementedException();
+ }
+
+ #endregion
+ }
+}
\ No newline at end of file
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/ResultWriter/ResultWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/ResultWriter/ResultWriter.cs
new file mode 100644
index 0000000000..a18a13594a
--- /dev/null
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/ResultWriter/ResultWriter.cs
@@ -0,0 +1,145 @@
+using System;
+using System.Linq;
+using System.Xml.Linq;
+using TUGraz.VectoCommon.Resources;
+using TUGraz.VectoCore.OutputData.XML.DeclarationReports.Common;
+
+namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.VehicleInformationFile.VehicleInformationFile_0_1.
+ ResultWriter
+{
+
+ public abstract class VIFResultWriterBase : AbstractResultGroupWriter
+ {
+ protected VIFResultWriterBase(ICommonResultsWriterFactory factory, XNamespace ns) : base(factory, ns) { }
+
+ #region Overrides of AbstractResultGroupWriter
+
+ public override XElement GetElement(IResultEntry entry)
+ {
+ return new XElement(TNS + XMLNames.Report_Result_Result,
+ new XAttribute(XMLNames.Report_Result_Status_Attr, "success"),
+ //new XAttribute(xsi + "type", ResultXMLType),
+ _factory.GetSuccessMissionWriter(_factory, TNS).GetElement(entry),
+ SimulationParameterWriter.GetElement(entry),
+ entry.FuelData.Select(f =>
+ FuelConsumptionWriter?.GetElement(entry, entry.FuelConsumptionFinal(f.FuelType))),
+ ElectricEnergyConsumptionWriter?.GetElement(entry)
+ );
+ }
+ #endregion
+
+ //public virtual string ResultXMLType => "ResultPrimaryVehicleType";
+
+ public abstract IResultGroupWriter SimulationParameterWriter { get; }
+
+ protected abstract IFuelConsumptionWriter FuelConsumptionWriter { get; }
+
+ protected abstract IElectricEnergyConsumptionWriter ElectricEnergyConsumptionWriter { get; }
+
+ }
+
+ public class VIFConvResultWriter : VIFResultWriterBase
+ {
+ public VIFConvResultWriter(ICommonResultsWriterFactory factory, XNamespace ns) : base(factory, ns) { }
+
+ #region Overrides of CIFResultWriterBase
+
+ public override IResultGroupWriter SimulationParameterWriter => _factory.GetBusSimulationParameterWriter(_factory, TNS);
+ protected override IFuelConsumptionWriter FuelConsumptionWriter => _factory.GetFuelConsumptionBus(_factory, TNS);
+ protected override IElectricEnergyConsumptionWriter ElectricEnergyConsumptionWriter => null;
+
+ #endregion
+ }
+
+ public class VIFHEVNonOVCResultWriter : VIFResultWriterBase
+ {
+ public VIFHEVNonOVCResultWriter(ICommonResultsWriterFactory factory, XNamespace ns) : base(factory, ns) { }
+
+ #region Overrides of CIFResultWriterBase
+
+ public override IResultGroupWriter SimulationParameterWriter => _factory.GetBusSimulationParameterWriter(_factory, TNS);
+ protected override IFuelConsumptionWriter FuelConsumptionWriter => _factory.GetFuelConsumptionBus(_factory, TNS);
+ protected override IElectricEnergyConsumptionWriter ElectricEnergyConsumptionWriter => _factory.GetElectricEnergyConsumptionBus(_factory, TNS);
+
+ #endregion
+ }
+
+ public class VIFPEVResultWriter : VIFResultWriterBase
+ {
+ public VIFPEVResultWriter(ICommonResultsWriterFactory factory, XNamespace ns) : base(factory, ns) { }
+
+ #region Overrides of CIFResultWriterBase
+
+ public override IResultGroupWriter SimulationParameterWriter => _factory.GetBusSimulationParameterWriter(_factory, TNS);
+ protected override IFuelConsumptionWriter FuelConsumptionWriter => null;
+ protected override IElectricEnergyConsumptionWriter ElectricEnergyConsumptionWriter => _factory.GetElectricEnergyConsumptionBus(_factory, TNS);
+
+ #endregion
+ }
+
+ public class VIFHEVOVCResultWriter : AbstractResultGroupWriter
+ {
+
+ public VIFHEVOVCResultWriter(ICommonResultsWriterFactory factory, XNamespace ns) : base(factory, ns) { }
+
+ #region Implementation of IResultGroupWriter
+
+ public override XElement GetElement(IResultEntry entry)
+ {
+ throw new NotImplementedException();
+ }
+
+ public override XElement GetElement(IOVCResultEntry entry)
+ {
+ return new XElement(TNS + XMLNames.Report_Result_Result,
+ new XAttribute(XMLNames.Report_Result_Status_Attr, "success"),
+ _factory.GetSuccessMissionWriter(_factory, TNS).GetElement(entry.ChargeDepletingResult),
+ _factory.GetBusSimulationParameterWriter(_factory, TNS).GetElement(entry.ChargeDepletingResult),
+ _factory.GetBusHEVOVCResultWriterChargeDepleting(_factory, TNS).GetElement(entry.ChargeDepletingResult),
+ _factory.GetBusHEVOVCResultWriterChargeSustaining(_factory, TNS).GetElement(entry.ChargeSustainingResult)
+ );
+ }
+
+ #endregion
+
+ }
+
+ public abstract class VIFOVCCModeWriterBase : AbstractResultGroupWriter
+ {
+ protected VIFOVCCModeWriterBase(ICommonResultsWriterFactory factory, XNamespace ns) : base(factory, ns) { }
+
+ public override XElement GetElement(IResultEntry entry)
+ {
+ return new XElement(TNS + "OVCMode",
+ new XAttribute("type", OVCMode),
+ entry.FuelData.Select(f =>
+ _factory.GetFuelConsumptionBus(_factory, TNS).GetElement(entry, entry.FuelConsumptionFinal(f.FuelType))),
+ _factory.GetElectricEnergyConsumptionBus(_factory, TNS).GetElement(entry)
+ );
+ }
+
+ public abstract string OVCMode { get; }
+ }
+
+ public class VIFOVCChargeDepletingWriter : VIFOVCCModeWriterBase
+ {
+ public VIFOVCChargeDepletingWriter(ICommonResultsWriterFactory factory, XNamespace ns) : base(factory, ns) { }
+
+ #region Overrides of VIFOVCCModeWriter
+
+ public override string OVCMode => "charge depleting";
+
+ #endregion
+ }
+
+ public class VIFOVCChargeSustainingWriter : VIFOVCCModeWriterBase
+ {
+ public VIFOVCChargeSustainingWriter(ICommonResultsWriterFactory factory, XNamespace ns) : base(factory, ns) { }
+
+ #region Overrides of VIFOVCCModeWriter
+
+ public override string OVCMode => "charge sustaining";
+
+ #endregion
+ }
+}
\ No newline at end of file
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/ResultWriter/VIFResultsWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/ResultWriter/VIFResultsWriter.cs
new file mode 100644
index 0000000000..c6ff97b8aa
--- /dev/null
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/ResultWriter/VIFResultsWriter.cs
@@ -0,0 +1,103 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+using TUGraz.VectoCommon.Resources;
+using TUGraz.VectoCore.Models.Simulation.Impl;
+using TUGraz.VectoCore.OutputData.XML.DeclarationReports.Common;
+using TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformationFile.CustomerInformationFile_0_9.ResultWriter;
+
+namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.VehicleInformationFile.VehicleInformationFile_0_1.ResultWriter
+{
+ public abstract class AbstractVIFFResultsWriter : AbstractResultsWriter
+ {
+ protected readonly IVIFResultsWriterFactory _vifFactory;
+
+ protected AbstractVIFFResultsWriter(IVIFResultsWriterFactory vifFactory)
+ {
+ _vifFactory = vifFactory;
+ }
+ protected override XNamespace TNS => "urn:tugraz:ivt:VectoAPI:DeclarationOutput:VehicleInterimFile:v0.1";
+
+ }
+
+ public class VIFResultsWriter
+ {
+ public class ConventionalBus : AbstractVIFFResultsWriter
+ {
+ public ConventionalBus(IVIFResultsWriterFactory vifFactory) : base(vifFactory) { }
+
+ protected override IResultGroupWriter ResultSuccessWriter => _vifFactory.GetBusConvSuccessResultWriter(_vifFactory, TNS);
+ protected override IResultGroupWriter ResultErrorWriter => _vifFactory.GetBusErrorResultWriter(_vifFactory, TNS);
+ public override IReportResultsSummaryWriter SummaryWriter => _vifFactory.GetBusConvSummaryWriter(_vifFactory, TNS);
+
+ }
+
+ public class HEVNonOVCBus : AbstractVIFFResultsWriter
+ {
+ public HEVNonOVCBus(IVIFResultsWriterFactory vifFactory) : base(vifFactory) { }
+
+ protected override IResultGroupWriter ResultSuccessWriter => _vifFactory.GetBusHEVNonOVCSuccessResultWriter(_vifFactory, TNS);
+ protected override IResultGroupWriter ResultErrorWriter => _vifFactory.GetBusErrorResultWriter(_vifFactory, TNS);
+ public override IReportResultsSummaryWriter SummaryWriter => _vifFactory.GetBusHEVNonOVCSummaryWriter(_vifFactory, TNS);
+
+ }
+
+ public class HEVOVCBus : AbstractVIFFResultsWriter
+ {
+ public HEVOVCBus(IVIFResultsWriterFactory vifFactory) : base(vifFactory) { }
+
+ public override XElement GenerateResults(List<IResultEntry> results)
+ {
+ var ordered = GetOrderedResultsOVC(results);
+ var allSuccess = results.All(x => x.Status == VectoRun.Status.Success);
+ return new XElement(TNS + "Results",
+ new XElement(TNS + XMLNames.Report_Result_Status, allSuccess ? "success" : "error"),
+ ordered.Select(x =>
+ x.ChargeDepletingResult.Status == VectoRun.Status.Success &&
+ x.ChargeSustainingResult.Status == VectoRun.Status.Success
+ ? ResultSuccessWriter.GetElement(x)
+ : ResultErrorWriter.GetElement(x)),
+ SummaryWriter.GetElement(ordered)
+ );
+ }
+
+ protected override IResultGroupWriter ResultSuccessWriter => _vifFactory.GetBusHEVOVCSuccessResultWriter(_vifFactory, TNS);
+ protected override IResultGroupWriter ResultErrorWriter => _vifFactory.GetBusErrorResultWriter(_vifFactory, TNS);
+ public override IReportResultsSummaryWriter SummaryWriter => _vifFactory.GetBusHEVOVCSummaryWriter(_vifFactory, TNS);
+
+ }
+
+ public class PEVBus : AbstractVIFFResultsWriter
+ {
+ public PEVBus(IVIFResultsWriterFactory vifFactory) : base(vifFactory) { }
+
+ protected override IResultGroupWriter ResultSuccessWriter => _vifFactory.GetBusPEVSuccessResultWriter(_vifFactory, TNS);
+ protected override IResultGroupWriter ResultErrorWriter => _vifFactory.GetBusErrorResultWriter(_vifFactory, TNS);
+ public override IReportResultsSummaryWriter SummaryWriter => _vifFactory.GetBusPEVSummaryWriter(_vifFactory, TNS);
+
+ }
+
+ public class ExemptedVehicle : AbstractVIFFResultsWriter
+ {
+ public ExemptedVehicle(IVIFResultsWriterFactory vifFactory) : base(vifFactory) { }
+
+ #region Implementation of IResultsWriter
+
+ public override XElement GenerateResults(List<IResultEntry> results)
+ {
+ return new XElement(TNS + "Results",
+ new XElement(TNS + "Status", "success"),
+ new XElement(TNS + "ExemptedVehicle"));
+ }
+
+ protected override IResultGroupWriter ResultSuccessWriter => null;
+ protected override IResultGroupWriter ResultErrorWriter => null;
+ public override IReportResultsSummaryWriter SummaryWriter => null;
+
+
+ #endregion
+
+
+ }
+ }
+}
\ No newline at end of file
diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/VIFResultsNinjectModule.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/VIFResultsNinjectModule.cs
new file mode 100644
index 0000000000..deaa694af5
--- /dev/null
+++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/VehicleInformationFile/VehicleInformationFile_0_1/VIFResultsNinjectModule.cs
@@ -0,0 +1,106 @@
+using System.Xml.Linq;
+using Ninject.Activation;
+using Ninject.Extensions.Factory;
+using Ninject.Modules;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCommon.Models;
+using TUGraz.VectoCore.OutputData.XML.DeclarationReports.Common;
+using TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformationFile.CustomerInformationFile_0_9.ResultWriter;
+using TUGraz.VectoCore.OutputData.XML.DeclarationReports.VehicleInformationFile.VehicleInformationFile_0_1.ResultWriter;
+using TUGraz.VectoCore.Utils;
+using TUGraz.VectoCore.Utils.Ninject;
+
+namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.VehicleInformationFile.VehicleInformationFile_0_1
+{
+ public class VIFResultsNinjectModule : NinjectModule
+ {
+ private VehicleTypeAndArchitectureStringHelperResults _namingHelper =
+ new VehicleTypeAndArchitectureStringHelperResults();
+
+ #region Overrides of NinjectModule
+
+ public override void Load()
+ {
+ Bind<IVIFResultsWriterFactory>().ToFactory().InSingletonScope();
+
+ var vif = XmlDocumentType.MultistepOutputData;
+ Bind<IResultsWriter>().To<VIFResultsWriter.ConventionalBus>().Named(
+ _namingHelper.GetName(vif, VehicleCategoryHelper.PrimaryBus, VectoSimulationJobTypeHelper.Conventional, false));
+ Bind<IResultsWriter>().To<VIFResultsWriter.HEVNonOVCBus>().Named(
+ _namingHelper.GetName(vif, VehicleCategoryHelper.PrimaryBus, VectoSimulationJobTypeHelper.Hybrid, false));
+ Bind<IResultsWriter>().To<VIFResultsWriter.HEVOVCBus>().Named(
+ _namingHelper.GetName(vif, VehicleCategoryHelper.PrimaryBus, VectoSimulationJobTypeHelper.Hybrid, true));
+ Bind<IResultsWriter>().To<VIFResultsWriter.PEVBus>().Named(
+ _namingHelper.GetName(vif, VehicleCategoryHelper.PrimaryBus, VectoSimulationJobTypeHelper.PureElectric, true));
+ Bind<IResultsWriter>().To<VIFResultsWriter.ExemptedVehicle>().Named(
+ _namingHelper.GetName(vif, VehicleCategoryHelper.PrimaryBus, true));
+
+ // --- Primary Bus
+
+ Bind<IResultGroupWriter>().To<VIFConvResultWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IVIFResultsWriterFactory c) => c.GetBusConvSuccessResultWriter(null, XNamespace.None));
+ Bind<IResultGroupWriter>().To<VIFHEVNonOVCResultWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IVIFResultsWriterFactory c) => c.GetBusHEVNonOVCSuccessResultWriter(null, XNamespace.None));
+ Bind<IResultGroupWriter>().To<VIFHEVOVCResultWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IVIFResultsWriterFactory c) => c.GetBusHEVOVCSuccessResultWriter(null, XNamespace.None));
+ Bind<IResultGroupWriter>().To<VIFOVCChargeDepletingWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IVIFResultsWriterFactory c) => c.GetBusHEVOVCResultWriterChargeDepleting(null, XNamespace.None));
+ Bind<IResultGroupWriter>().To<VIFOVCChargeSustainingWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IVIFResultsWriterFactory c) => c.GetBusHEVOVCResultWriterChargeSustaining(null, XNamespace.None));
+ Bind<IResultGroupWriter>().To<VIFPEVResultWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IVIFResultsWriterFactory c) => c.GetBusPEVSuccessResultWriter(null, XNamespace.None));
+
+ Bind<IResultSequenceWriter>().To<VIFResultSuccessMissionWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IMRFResultsWriterFactory c) => c.GetSuccessMissionWriter(null, XNamespace.None));
+ Bind<IResultGroupWriter>().To<ResultSimulationParameterVIFBusWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IVIFResultsWriterFactory c) => c.GetBusSimulationParameterWriter(null, XNamespace.None));
+
+ Bind<IResultGroupWriter>().To<VehiclePerformanceVIFWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IMRFResultsWriterFactory c) => c.GetVehiclePerformanceBus(null, XNamespace.None));
+ Bind<IResultGroupWriter>().To<VehiclePerformanceVIFWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IMRFResultsWriterFactory c) => c.GetVehiclePerformancePEVBus(null, XNamespace.None));
+
+ Bind<IFuelConsumptionWriter>().To<VIFFuelConsumptionWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IMRFResultsWriterFactory c) => c.GetFuelConsumptionBus(null, XNamespace.None));
+ Bind<IElectricEnergyConsumptionWriter>().To<VIFElectricEnergyConsumptionWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IMRFResultsWriterFactory c) => c.GetElectricEnergyConsumptionBus(null, XNamespace.None));
+ Bind<ICO2Writer>().To<VIFCO2Writer>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IMRFResultsWriterFactory c) => c.GetCO2ResultBus(null, XNamespace.None));
+ Bind<ICO2Writer>().To<VIFCO2Writer>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IMRFResultsWriterFactory c) => c.GetCO2ResultPEVBus(null, XNamespace.None));
+
+
+ Bind<IResultGroupWriter>().To<VIFErrorResultWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IVIFResultsWriterFactory c) => c.GetBusErrorResultWriter(null, XNamespace.None));
+ Bind<IResultSequenceWriter>().To<VIFResultErrorMissionWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IVIFResultsWriterFactory c) => c.GetErrorMissionWriter(null, XNamespace.None));
+ Bind<IResultGroupWriter>().To<VIFResultSimulationParameterErrorWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IVIFResultsWriterFactory c) => c.GetErrorSimulationParameterWriter(null, XNamespace.None));
+ Bind<IResultSequenceWriter>().To<VIFErrorDetailsWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((ICIFResultsWriterFactory c) => c.GetErrorDetailsWriter(null, XNamespace.None));
+
+
+
+ Bind<IReportResultsSummaryWriter>().To<NoSummaryWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IVIFResultsWriterFactory c) => c.GetBusConvSummaryWriter(null, XNamespace.None));
+ Bind<IReportResultsSummaryWriter>().To<NoSummaryWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IVIFResultsWriterFactory c) => c.GetBusHEVNonOVCSummaryWriter(null, XNamespace.None));
+ Bind<IReportResultsSummaryWriter>().To<NoSummaryWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IVIFResultsWriterFactory c) => c.GetBusHEVOVCSummaryWriter(null, XNamespace.None));
+ Bind<IReportResultsSummaryWriter>().To<NoSummaryWriter>().When(AccessedViaVIFResultsWriterFactory)
+ .NamedLikeFactoryMethod((IVIFResultsWriterFactory c) => c.GetBusPEVSummaryWriter(null, XNamespace.None));
+
+ }
+
+ #endregion
+
+ private bool AccessedViaVIFResultsWriterFactory(IRequest request)
+ {
+ if (request.ParentRequest == null) {
+ return false;
+ }
+
+ return typeof(IVIFResultsWriterFactory).IsAssignableFrom(request.ParentRequest.Service);
+ }
+ }
+}
\ No newline at end of file
diff --git a/VectoCore/VectoCore/VectoCore.csproj b/VectoCore/VectoCore/VectoCore.csproj
index a3ed1b0696..6676e568f5 100644
--- a/VectoCore/VectoCore/VectoCore.csproj
+++ b/VectoCore/VectoCore/VectoCore.csproj
@@ -145,6 +145,7 @@
<Folder Include="InputData\Reader\DataObjectAdapter\CompletedBus\Generic\" />
<Folder Include="InputData\Reader\DataObjectAdapter\SimulationComponents\StrategyDataAdapter\" />
<Folder Include="Models\SimulationComponent\Impl\Controller\" />
+ <Folder Include="OutputData\XML\DeclarationReports\VehicleInformationFile\VehicleInformationFile_0_1\ResultWriter\" />
</ItemGroup>
</Project>
\ No newline at end of file
diff --git a/VectoCore/VectoCoreTest/Reports/TestXMLResultsWriting.cs b/VectoCore/VectoCoreTest/Reports/TestXMLResultsWriting.cs
index 03bbe5a9a6..edf6a7fdf7 100644
--- a/VectoCore/VectoCoreTest/Reports/TestXMLResultsWriting.cs
+++ b/VectoCore/VectoCoreTest/Reports/TestXMLResultsWriting.cs
@@ -24,6 +24,7 @@ using TUGraz.VectoCore.OutputData.XML.DeclarationReports.Common;
using TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformationFile;
using TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformationFile.CustomerInformationFile_0_9;
using TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformationFile.CustomerInformationFile_0_9.ResultWriter;
+using TUGraz.VectoCore.OutputData.XML.DeclarationReports.VehicleInformationFile.VehicleInformationFile_0_1.ResultWriter;
using TUGraz.VectoCore.Utils;
using XmlDocumentType = TUGraz.VectoCore.Utils.XmlDocumentType;
@@ -39,6 +40,7 @@ public class TestXMLResultsWriting
XNamespace CIF_NS = XNamespace.Get("urn:tugraz:ivt:VectoAPI:CustomerOutput:v0.9");
XNamespace MRF_NS = XNamespace.Get("urn:tugraz:ivt:VectoAPI:DeclarationOutput:v0.9");
+ XNamespace VIF_NS = XNamespace.Get("urn:tugraz:ivt:VectoAPI:DeclarationOutput:VehicleInterimFile:v0.1");
[OneTimeSetUp]
public void OneTimeSetup()
@@ -56,6 +58,14 @@ public class TestXMLResultsWriting
TestCase(VehicleCategory.RigidTruck, VectoSimulationJobType.ParallelHybridVehicle, false, false, typeof(CIFResultsWriter.HEVNonOVCLorry)),
TestCase(VehicleCategory.RigidTruck, VectoSimulationJobType.SerialHybridVehicle, true, false, typeof(CIFResultsWriter.HEVOVCLorry)),
TestCase(VehicleCategory.RigidTruck, VectoSimulationJobType.BatteryElectricVehicle, true, false, typeof(CIFResultsWriter.PEVLorry)),
+
+ TestCase(VehicleCategory.HeavyBusCompletedVehicle, VectoSimulationJobType.ConventionalVehicle, false, true, typeof(CIFResultsWriter.ExemptedVehicle)),
+ TestCase(VehicleCategory.HeavyBusCompletedVehicle, VectoSimulationJobType.ConventionalVehicle, false, false, typeof(CIFResultsWriter.ConventionalBus)),
+ TestCase(VehicleCategory.HeavyBusCompletedVehicle, VectoSimulationJobType.ConventionalVehicle, false, false, typeof(CIFResultsWriter.ConventionalBus)),
+ TestCase(VehicleCategory.HeavyBusCompletedVehicle, VectoSimulationJobType.ParallelHybridVehicle, false, false, typeof(CIFResultsWriter.HEVNonOVCBus)),
+ TestCase(VehicleCategory.HeavyBusCompletedVehicle, VectoSimulationJobType.SerialHybridVehicle, true, false, typeof(CIFResultsWriter.HEVOVCBus)),
+ TestCase(VehicleCategory.HeavyBusCompletedVehicle, VectoSimulationJobType.BatteryElectricVehicle, true, false, typeof(CIFResultsWriter.PEVBus)),
+
]
public void Test_CIF_ReportResultInstance(VehicleCategory vehicleCategory, VectoSimulationJobType jobType, bool ovc,
bool exempted, Type expectedResultWriterType)
@@ -115,7 +125,7 @@ public class TestXMLResultsWriting
Assert.NotNull(results);
- var doc = CreateXmlDocument(results, "VectoOutputCustomer", CIF_NS);
+ var doc = CreateXmlDocument(results, "VectoOutputCustomer.0.9", CIF_NS);
var validator = GetValidator(doc);
WriteToConsole(doc);
@@ -180,7 +190,7 @@ public class TestXMLResultsWriting
Assert.NotNull(results);
- var doc = CreateXmlDocument(results, "VectoOutputCustomer", CIF_NS);
+ var doc = CreateXmlDocument(results, "VectoOutputCustomer.0.9", CIF_NS);
var validator = GetValidator(doc);
WriteToConsole(doc);
@@ -201,6 +211,12 @@ public class TestXMLResultsWriting
TestCase(VehicleCategory.RigidTruck, VectoSimulationJobType.ParallelHybridVehicle, false, false, typeof(MRFResultsWriter.HEVNonOVCLorry)),
TestCase(VehicleCategory.RigidTruck, VectoSimulationJobType.SerialHybridVehicle, true, false, typeof(MRFResultsWriter.HEVOVCLorry)),
TestCase(VehicleCategory.RigidTruck, VectoSimulationJobType.BatteryElectricVehicle, true, false, typeof(MRFResultsWriter.PEVLorry)),
+
+ TestCase(VehicleCategory.HeavyBusCompletedVehicle, VectoSimulationJobType.ConventionalVehicle, false, true, typeof(MRFResultsWriter.ExemptedVehicle)),
+ TestCase(VehicleCategory.HeavyBusCompletedVehicle, VectoSimulationJobType.ConventionalVehicle, false, false, typeof(MRFResultsWriter.ConventionalBus)),
+ TestCase(VehicleCategory.HeavyBusCompletedVehicle, VectoSimulationJobType.ParallelHybridVehicle, false, false, typeof(MRFResultsWriter.HEVNonOVCBus)),
+ TestCase(VehicleCategory.HeavyBusCompletedVehicle, VectoSimulationJobType.SerialHybridVehicle, true, false, typeof(MRFResultsWriter.HEVOVCBus)),
+ TestCase(VehicleCategory.HeavyBusCompletedVehicle, VectoSimulationJobType.BatteryElectricVehicle, true, false, typeof(MRFResultsWriter.PEVBus)),
]
public void Test_MRF_ReportResultInstance(VehicleCategory vehicleCategory, VectoSimulationJobType jobType, bool ovc,
bool exempted, Type expectedResultWriterType)
@@ -260,7 +276,7 @@ public class TestXMLResultsWriting
Assert.NotNull(results);
- var doc = CreateXmlDocument(results, "VectoOutputManufacturer", MRF_NS);
+ var doc = CreateXmlDocument(results, "VectoOutputManufacturer.0.9", MRF_NS);
var validator = GetValidator(doc);
WriteToConsole(doc);
@@ -319,7 +335,7 @@ public class TestXMLResultsWriting
Assert.NotNull(results);
- var doc = CreateXmlDocument(results, "VectoOutputManufacturer", MRF_NS);
+ var doc = CreateXmlDocument(results, "VectoOutputManufacturer.0.9", MRF_NS);
var validator = GetValidator(doc);
WriteToConsole(doc);
@@ -329,7 +345,82 @@ public class TestXMLResultsWriting
WriteToFile("MRF", doc, runData, success, exempted);
}
+ // ------------
+ // VIF Tests
+
+ [
+ TestCase(VehicleCategory.HeavyBusPrimaryVehicle, VectoSimulationJobType.ConventionalVehicle, false, true, typeof(VIFResultsWriter.ExemptedVehicle)),
+ TestCase(VehicleCategory.HeavyBusPrimaryVehicle, VectoSimulationJobType.ConventionalVehicle, false, false, typeof(VIFResultsWriter.ConventionalBus)),
+ TestCase(VehicleCategory.HeavyBusPrimaryVehicle, VectoSimulationJobType.ParallelHybridVehicle, false, false, typeof(VIFResultsWriter.HEVNonOVCBus)),
+ TestCase(VehicleCategory.HeavyBusPrimaryVehicle, VectoSimulationJobType.SerialHybridVehicle, true, false, typeof(VIFResultsWriter.HEVOVCBus)),
+ TestCase(VehicleCategory.HeavyBusPrimaryVehicle, VectoSimulationJobType.BatteryElectricVehicle, true, false, typeof(VIFResultsWriter.PEVBus)),
+ ]
+ public void Test_VIF_ReportResultInstance(VehicleCategory vehicleCategory, VectoSimulationJobType jobType, bool ovc,
+ bool exempted, Type expectedResultWriterType)
+ {
+ var resultsWriter = _reportResultsFactory.GetVIFResultsWriter(vehicleCategory.GetVehicleType(), jobType, ovc, exempted);
+
+ Assert.AreEqual(expectedResultWriterType, resultsWriter.GetType());
+ }
+
+ [
+ TestCase(VectoSimulationJobType.ConventionalVehicle, false, false, true, TestName = "VIF_ReportResult_WritingResults: PrimaryBus Conv SUCCESS"),
+ TestCase(VectoSimulationJobType.ConventionalVehicle, false, false, true, FuelType.NGCI, FuelType.DieselCI, TestName = "VIF_ReportResult_WritingResults: PrimaryBus Conv DualFuel SUCCESS"),
+ TestCase(VectoSimulationJobType.ConventionalVehicle, false, false, true, FuelType.NGPI, TestName = "VIF_ReportResult_WritingResults: PrimaryBus Conv LNG SUCCESS"),
+ TestCase(VectoSimulationJobType.ConventionalVehicle, false, false, false, TestName = "VIF_ReportResult_WritingResults: PrimaryBus Conv ERROR"),
+ TestCase(VectoSimulationJobType.ParallelHybridVehicle, true, false, true, TestName = "VIF_ReportResult_WritingResults: PrimaryBus HEV OVC SUCCESS"),
+ TestCase(VectoSimulationJobType.SerialHybridVehicle, true, false, true, FuelType.NGCI, FuelType.DieselCI, TestName = "VIF_ReportResult_WritingResults: PrimaryBus HEV OVC DualFuel SUCCESS"),
+ TestCase(VectoSimulationJobType.IEPC_S, true, false, true, FuelType.NGPI, TestName = "VIF_ReportResult_WritingResults: PrimaryBus HEV OVC LNG SUCCESS"),
+ TestCase(VectoSimulationJobType.ParallelHybridVehicle, true, false, false, TestName = "VIF_ReportResult_WritingResults: PrimaryBus HEV OVC ERROR"),
+
+ TestCase(VectoSimulationJobType.ParallelHybridVehicle, false, false, true, TestName = "VIF_ReportResult_WritingResults: PrimaryBus HEV non-OVC SUCCESS"),
+ TestCase(VectoSimulationJobType.ParallelHybridVehicle, false, false, false, TestName = "VIF_ReportResult_WritingResults: PrimaryBus HEV non-OVC ERROR"),
+
+ TestCase(VectoSimulationJobType.BatteryElectricVehicle, true, false, true, TestName = "VIF_ReportResult_WritingResults: PrimaryBus PEV SUCCESS"),
+ TestCase(VectoSimulationJobType.BatteryElectricVehicle, true, false, false, TestName = "VIF_ReportResult_WritingResults: PrimaryBus PEV ERROR"),
+
+ TestCase(VectoSimulationJobType.ParallelHybridVehicle, true, true, true, TestName = "VIF_ReportResult_WritingResults: PrimaryBus HEV exempted"),
+ TestCase(VectoSimulationJobType.ConventionalVehicle, true, true, true, TestName = "VIF_ReportResult_WritingResults: PrimaryBus Conv exempted"),
+ ]
+ public void Test_VIF_ReportResult_WritingResults_Bus(VectoSimulationJobType jobType, bool ovc, bool exempted, bool success, params FuelType[] fuels)
+ {
+ var vehicleCategory = VehicleCategory.HeavyBusPrimaryVehicle;
+ var ovcmode = ovc ? VectoRunData.OvcHevMode.ChargeDepleting : VectoRunData.OvcHevMode.NotApplicable;
+ var runData = GetMockRunData(vehicleCategory, jobType, ovc, exempted, ovcmode, fuels);
+ var modData = GetMockModData(success ? VectoRun.Status.Success : VectoRun.Status.Aborted, fuels);
+
+ var resultEntries = new List<IResultEntry>();
+
+ var resultEntry = GetResultEntry(runData);
+ resultEntry.SetResultData(runData, modData, 1);
+
+ resultEntries.Add(resultEntry);
+
+ if (ovc && jobType.GetPowertrainArchitectureType() == VectoSimulationJobTypeHelper.Hybrid) {
+ var run2 = GetMockRunData(vehicleCategory, jobType, true, exempted, VectoRunData.OvcHevMode.ChargeSustaining, fuels);
+ var res2 = GetResultEntry(run2);
+ res2.SetResultData(run2, modData, 1);
+ resultEntries.Add(res2);
+ }
+
+ var resultsWriter = _reportResultsFactory.GetVIFResultsWriter(
+ runData.VehicleData.VehicleCategory.GetVehicleType(),
+ runData.JobType, runData.VehicleData.OffVehicleCharging, runData.Exempted);
+
+ var results = resultsWriter.GenerateResults(resultEntries);
+
+ Assert.NotNull(results);
+
+ var doc = CreateXmlDocument(results, "VectoOutputMultistep.0.1", VIF_NS);
+ var validator = GetValidator(doc);
+
+ WriteToConsole(doc);
+
+ Assert.IsTrue(validator.ValidateXML(XmlDocumentType.MultistepOutputData), validator.ValidationError);
+
+ WriteToFile("VIF", doc, runData, success, exempted);
+ }
// ===================================
@@ -426,7 +517,7 @@ public class TestXMLResultsWriting
var doc = new XDocument();
doc.Add(new XElement(ns + "VectoMockResults",
new XAttribute(XNamespace.Xmlns + "xsi", xsi.NamespaceName),
- new XAttribute(xsi + "schemaLocation", $@"{ns.NamespaceName} V:\VectoCore\VectoCore\Resources\XSD\{reportType}.0.9.xsd"),
+ new XAttribute(xsi + "schemaLocation", $@"{ns.NamespaceName} V:\VectoCore\VectoCore\Resources\XSD\{reportType}.xsd"),
results));
return doc;
--
GitLab