diff --git a/VectoCore/VectoCore/Models/Declaration/DeclarationData.cs b/VectoCore/VectoCore/Models/Declaration/DeclarationData.cs index 48886119958fd877f586e749c1aa07c328529732..f12c9bb6163997db46521abb3e04e4e72af0244e 100644 --- a/VectoCore/VectoCore/Models/Declaration/DeclarationData.cs +++ b/VectoCore/VectoCore/Models/Declaration/DeclarationData.cs @@ -52,8 +52,10 @@ using TUGraz.VectoCore.Models.SimulationComponent.Data.Engine; using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox; using TUGraz.VectoCore.Utils; using TUGraz.VectoCore.Models.BusAuxiliaries.DownstreamModules.Impl.HVAC; +using TUGraz.VectoCore.Models.Simulation.Data; using TUGraz.VectoCore.Models.Simulation.Impl; using TUGraz.VectoCore.OutputData; +using TUGraz.VectoCore.OutputData.XML; namespace TUGraz.VectoCore.Models.Declaration { @@ -1392,7 +1394,50 @@ namespace TUGraz.VectoCore.Models.Declaration public static IWeightedResult CalculateWeightedSummary(IList<IResultEntry> entries) { - throw new NotImplementedException(); + // ToDo MQ 2022-12-12: add correct calculation method! + var cdResult = entries.First(); + var csResult = entries.First(); + return new WeightedResult(cdResult) { + AverageSpeed = cdResult.AverageSpeed, + FuelConsumption = cdResult.FuelData.Select(x => Tuple.Create(x, + (cdResult.FuelConsumptionFinal(x.FuelType).TotalFuelConsumptionCorrected + + csResult.FuelConsumptionFinal(x.FuelType).TotalFuelConsumptionCorrected) / 2.0)) + .ToDictionary(x => x.Item1, x => x.Item2), + ElectricEnergyConsumption = (cdResult.ElectricEnergyConsumption + csResult.ElectricEnergyConsumption) / 2.0, + CO2Total = (cdResult.CO2Total + csResult.CO2Total) / 2.0, + ActualChargeDepletingRange = cdResult.Distance, + EquivalentAllElectricRange = cdResult.Distance, + ZeroCO2EmissionsRange = cdResult.Distance, + UtilityFactor = 1 + }; + } + + public static IWeightedResult CalculateWeightedSummary(IList<IOVCResultEntry> entries) + { + // ToDo MQ 2022-12-12: add correct calculation method! + var cdResult = entries.First().ChargeDepletingResult; + var csResult = entries.First().ChargeSustainingResult; + return new WeightedResult(cdResult) { + AverageSpeed = cdResult.AverageSpeed, + FuelConsumption = cdResult.FuelData.Select(x => Tuple.Create(x, + (cdResult.FuelConsumptionFinal(x.FuelType).TotalFuelConsumptionCorrected + + csResult.FuelConsumptionFinal(x.FuelType).TotalFuelConsumptionCorrected) / 2.0)) + .ToDictionary(x => x.Item1, x => x.Item2), + ElectricEnergyConsumption = (cdResult.ElectricEnergyConsumption + csResult.ElectricEnergyConsumption) / 2.0, + CO2Total = (cdResult.CO2Total + csResult.CO2Total) / 2.0, + ActualChargeDepletingRange = cdResult.Distance, + EquivalentAllElectricRange = cdResult.Distance, + ZeroCO2EmissionsRange = cdResult.Distance, + UtilityFactor = 1 + }; + } + + public static void SetElectricRangesPEV(IResultEntry resultEntry, VectoRunData runData, IModalDataContainer data) + { + // ToDo MQ 2022-12-12: add correct calculation method! + resultEntry.ActualChargeDepletingRange = 100.SI<Meter>(); + resultEntry.EquivalentAllElectricRange = 100.SI<Meter>(); + resultEntry.ZeroCO2EmissionsRange = 100.SI<Meter>(); } } } diff --git a/VectoCore/VectoCore/OutputData/DeclarationReport.cs b/VectoCore/VectoCore/OutputData/DeclarationReport.cs index c8ae48ad8c4dc8c249f915da9e4a7e4170983a0e..039013acc8c727bb6a46864ce4ae493cf615c4e9 100644 --- a/VectoCore/VectoCore/OutputData/DeclarationReport.cs +++ b/VectoCore/VectoCore/OutputData/DeclarationReport.cs @@ -113,6 +113,12 @@ namespace TUGraz.VectoCore.OutputData double WeightingFactor { get; } + Meter ActualChargeDepletingRange { get; set; } + + Meter EquivalentAllElectricRange { get; set; } + + Meter ZeroCO2EmissionsRange { get; set; } + void SetResultData(VectoRunData runData, IModalDataContainer data, double weightingFactor); string Error { get; } diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFNinjectModule.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFNinjectModule.cs index 5028fb0a44afab3dd737fc9f2e2946a3b208dd54..998dc08e3f7e8fce0f277befb527dff85cc0995a 100644 --- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFNinjectModule.cs +++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/CIFNinjectModule.cs @@ -444,40 +444,61 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation Bind<ICifResultsWriterFactory>().ToFactory().InSingletonScope(); + Bind<IElectricRangeWriter>().To<ElectricRangeWriter>().When(AccessedViaCIFResultsWriterFactory) + .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetElectricRangeWriter()); + // -- Lorry - Bind<IResultGroupWriter>().To<LorryOVCResultWriter>().When(AccessedViaCIFResultsWriterFactory) - .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryOVCSuccessResultWriter()); + Bind<IResultGroupWriter>().To<LorryConvResultWriter>().When(AccessedViaCIFResultsWriterFactory) + .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryConvSuccessResultWriter()); + Bind<IResultGroupWriter>().To<LorryHEVNonOVCResultWriter>().When(AccessedViaCIFResultsWriterFactory) + .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryHEVNonOVCSuccessResultWriter()); + Bind<IResultGroupWriter>().To<LorryHEVOVCResultWriter>().When(AccessedViaCIFResultsWriterFactory) + .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryHEVOVCSuccessResultWriter()); + Bind<IResultGroupWriter>().To<LorryPEVResultWriter>().When(AccessedViaCIFResultsWriterFactory) + .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryPEVSuccessResultWriter()); Bind<IResultGroupWriter>().To<ErrorResultWriter>().When(AccessedViaCIFResultsWriterFactory) - .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryOVCErrorResultWriter()); + .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryErrorResultWriter()); Bind<IResultGroupWriter>().To<ResultMissionWriter>().When(AccessedViaCIFResultsWriterFactory) .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetMissionWriter()); Bind<IResultGroupWriter>().To<ResultSimulationParameterLorryWriter>().When(AccessedViaCIFResultsWriterFactory) .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorrySimulationParameterWriter()); - Bind<IResultGroupWriter>().To<LorryOVCChargeDepletingWriter>().When(AccessedViaCIFResultsWriterFactory) - .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryOVCResultWriterChargeDepleting()); - Bind<IResultGroupWriter>().To<LorryOVCChargeSustainingWriter>().When(AccessedViaCIFResultsWriterFactory) - .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryOVCResultWriterChargeSustaining()); - Bind<IResultGroupWriter>().To<LorryOVCTotalWriter>().When(AccessedViaCIFResultsWriterFactory) - .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryOVCSummaryWriter()); + Bind<IResultGroupWriter>().To<LorryConvTotalWriter>().When(AccessedViaCIFResultsWriterFactory) + .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryConvTotalWriter()); + Bind<IResultGroupWriter>().To<LorryHEVNonOVCTotalWriter>().When(AccessedViaCIFResultsWriterFactory) + .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryHEVNonOVCTotalWriter()); + Bind<IResultGroupWriter>().To<LorryHEVOVCChargeDepletingWriter>().When(AccessedViaCIFResultsWriterFactory) + .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryHEVOVCResultWriterChargeDepleting()); + Bind<IResultGroupWriter>().To<LorryHEVOVCChargeSustainingWriter>().When(AccessedViaCIFResultsWriterFactory) + .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryHEVOVCResultWriterChargeSustaining()); + Bind<IResultGroupWriter>().To<LorryHEVOVCTotalWriter>().When(AccessedViaCIFResultsWriterFactory) + .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryHEVOVCTotalWriter()); + Bind<IResultGroupWriter>().To<LorryPEVTotalWriter>().When(AccessedViaCIFResultsWriterFactory) + .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryPEVTotalWriter()); Bind<IFuelConsumptionWriter>().To<LorryFuelConsumptionWriter>().When(AccessedViaCIFResultsWriterFactory) .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetFuelConsumptionLorry()); - Bind<IResultGroupWriter>().To<LorryElectricEnergyConsumptionWriter>().When(AccessedViaCIFResultsWriterFactory) + Bind<IElectricEnergyConsumptionWriter>().To<LorryElectricEnergyConsumptionWriter>().When(AccessedViaCIFResultsWriterFactory) .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetElectricEnergyConsumptionLorry()); Bind<ICO2Writer>().To<LorryCO2Writer>().When(AccessedViaCIFResultsWriterFactory) .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetCO2ResultLorry()); - Bind<ICifSummaryWriter>().To<LorryOVCCifSummaryWriter>().When(AccessedViaCIFResultsWriterFactory) - .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryOVCCifSummaryWriter()); + Bind<ICifSummaryWriter>().To<LorryConvSummaryWriter>().When(AccessedViaCIFResultsWriterFactory) + .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryConvSummaryWriter()); + Bind<ICifSummaryWriter>().To<LorryHEVNonOVCSummaryWriter>().When(AccessedViaCIFResultsWriterFactory) + .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryHEVNonOVCSummaryWriter()); + Bind<ICifSummaryWriter>().To<LorryHEVOVCSummaryWriter>().When(AccessedViaCIFResultsWriterFactory) + .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryHEVOVCSummaryWriter()); + Bind<ICifSummaryWriter>().To<LorryPEVSummaryWriter>().When(AccessedViaCIFResultsWriterFactory) + .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetLorryPEVSummaryWriter()); // -- Bus - Bind<IResultGroupWriter>().To<BusOVCTotalWriter>().When(AccessedViaCIFResultsWriterFactory) + Bind<IResultGroupWriter>().To<BusHEVOVCResultWriter>().When(AccessedViaCIFResultsWriterFactory) .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetBusOVCSuccessResultWriter()); Bind<IResultGroupWriter>().To<ErrorResultWriter>().When(AccessedViaCIFResultsWriterFactory) .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetBusOVCErrorResultWriter()); @@ -489,12 +510,12 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetBusOVCResultWriterChargeDepleting()); Bind<IResultGroupWriter>().To<BusOVCChargeSustainingWriter>().When(AccessedViaCIFResultsWriterFactory) .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetBusOVCResultWriterChargeSustaining()); - Bind<IResultGroupWriter>().To<BusOVCSummaryWriter>().When(AccessedViaCIFResultsWriterFactory) - .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetBusOVCSummaryWriter()); + Bind<IResultGroupWriter>().To<BusOVCTotalWriter>().When(AccessedViaCIFResultsWriterFactory) + .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetBusOVCTotalWriter()); Bind<IFuelConsumptionWriter>().To<BusFuelConsumptionWriter>().When(AccessedViaCIFResultsWriterFactory) .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetFuelConsumptionBus()); - Bind<IResultGroupWriter>().To<BusElectricEnergyConsumptionWriter>().When(AccessedViaCIFResultsWriterFactory) + Bind<IElectricEnergyConsumptionWriter>().To<BusElectricEnergyConsumptionWriter>().When(AccessedViaCIFResultsWriterFactory) .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetElectricEnergyConsumptionBus()); Bind<ICO2Writer>().To<BusCO2Writer>().When(AccessedViaCIFResultsWriterFactory) .NamedLikeFactoryMethod((ICifResultsWriterFactory c) => c.GetCO2ResultBus()); diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/CIFResultWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/CIFResultWriter.cs new file mode 100644 index 0000000000000000000000000000000000000000..10aa89f94b851dcafe055aa1c4fbb1f76a34cf5f --- /dev/null +++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/CIFResultWriter.cs @@ -0,0 +1,243 @@ +using System.Collections.Generic; +using System.Linq; +using System.Xml.Linq; +using TUGraz.VectoCommon.Exceptions; +using TUGraz.VectoCommon.Resources; +using TUGraz.VectoCommon.Utils; +using TUGraz.VectoCore.Models.Declaration; +using TUGraz.VectoCore.Models.Simulation.Data; +using TUGraz.VectoCore.Models.Simulation.Impl; + +namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformationFile.CustomerInformationFile_0_9.ResultWriter +{ + public abstract class AbstractResultsWriter : IResultsWriter + { + protected static readonly XNamespace Cif = "urn:tugraz:ivt:VectoAPI:CustomerOutput:v0.9"; + + protected readonly ICifResultsWriterFactory _cifFactory; + + protected AbstractResultsWriter(ICifResultsWriterFactory cifFactory) + { + _cifFactory = cifFactory; + } + + #region Implementation of IResultsWriter + + public virtual XElement GenerateResults(List<IResultEntry> results) + { + var ordered = GetOrderedResults(results); + var allSuccess = results.All(x => x.Status == VectoRun.Status.Success); + return new XElement(Cif + "Results", + new XElement(Cif + XMLNames.Report_Result_Status, allSuccess ? "success" : "error"), + ordered.Select(x => + x.Status == VectoRun.Status.Success + ? ResultSuccessWriter.GetElement(x) + : ResultErrorWriter.GetElement(x)), + allSuccess ? SummaryWriter.GetElement(ordered) : null + ); + } + + public abstract ICifSummaryWriter SummaryWriter { get; } + + #endregion + protected abstract IResultGroupWriter ResultSuccessWriter { get; } + + protected abstract IResultGroupWriter ResultErrorWriter { get; } + + protected virtual IList<IResultEntry> GetOrderedResults(List<IResultEntry> results) + { + return results.OrderBy(x => x.VehicleClass) + .ThenBy(x => x.FuelMode) + .ThenBy(x => x.Mission) + .ThenBy(x => x.LoadingType).ToArray(); + } + + protected virtual List<IOVCResultEntry> GetOrderedResultsOVC(List<IResultEntry> results) + { + if (!results.All(x => x.OVCMode.IsOneOf(VectoRunData.OvcHevMode.ChargeSustaining, VectoRunData.OvcHevMode.ChargeDepleting))) { + throw new VectoException( + "Simulation runs for OVC vehicles must be either Charge Sustaining or Charge Depleting!"); + } + + var retVal = new List<IOVCResultEntry>(results.Count / 2); + var cdEntries = results.Where(x => x.OVCMode == VectoRunData.OvcHevMode.ChargeSustaining) + .OrderBy(x => x.VehicleClass) + .ThenBy(x => x.FuelMode) + .ThenBy(x => x.Mission) + .ThenBy(x => x.LoadingType) + .ToList(); + foreach (var cdEntry in cdEntries) { + var csEntry = results.FirstOrDefault(x => x.OVCMode != cdEntry.OVCMode && + x.VehicleClass == cdEntry.VehicleClass && + x.FuelMode == cdEntry.FuelMode && + x.Mission == cdEntry.Mission && + x.LoadingType == cdEntry.LoadingType); + if (csEntry == null) { + throw new VectoException( + $"no matching result for {cdEntry.Mission}, {cdEntry.LoadingType}, {cdEntry.FuelMode} found!"); + } + + var combined = new OvcResultEntry() { + ChargeSustainingResult = csEntry, + ChargeDepletingResult = cdEntry, + Weighted = DeclarationData.CalculateWeightedResult(cdEntry, csEntry) + }; + retVal.Add(combined); + } + return retVal; + } + + } + + public class CIFResultsWriter + { + + public class ConventionalLorry : AbstractResultsWriter + { + public ConventionalLorry(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Overrides of AbstractResultsWriter + + protected override IResultGroupWriter ResultSuccessWriter => _cifFactory.GetLorryConvSuccessResultWriter(); + + protected override IResultGroupWriter ResultErrorWriter => _cifFactory.GetLorryErrorResultWriter(); + + public override ICifSummaryWriter SummaryWriter => _cifFactory.GetLorryConvSummaryWriter(); + + #endregion + } + + public class HEVNonOVCLorry : AbstractResultsWriter + { + public HEVNonOVCLorry(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + protected override IResultGroupWriter ResultSuccessWriter => _cifFactory.GetLorryHEVNonOVCSuccessResultWriter(); + protected override IResultGroupWriter ResultErrorWriter => _cifFactory.GetLorryErrorResultWriter(); + + public override ICifSummaryWriter SummaryWriter => _cifFactory.GetLorryHEVNonOVCSummaryWriter(); + + } + + public class HEVOVCLorry : AbstractResultsWriter + { + public HEVOVCLorry(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Overrides of AbstractResultsWriter + + public override XElement GenerateResults(List<IResultEntry> results) + { + var ordered = GetOrderedResultsOVC(results); + var allSuccess = results.All(x => x.Status == VectoRun.Status.Success); + return new XElement(Cif + "Results", + new XElement(Cif + 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) + ); + } + + #endregion + + protected override IResultGroupWriter ResultSuccessWriter => _cifFactory.GetLorryHEVOVCSuccessResultWriter(); + protected override IResultGroupWriter ResultErrorWriter => _cifFactory.GetLorryErrorResultWriter(); + + public override ICifSummaryWriter SummaryWriter => _cifFactory.GetLorryHEVOVCSummaryWriter(); + + } + + public class PEVLorry : AbstractResultsWriter + { + public PEVLorry(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + protected override IResultGroupWriter ResultSuccessWriter => _cifFactory.GetLorryPEVSuccessResultWriter(); + protected override IResultGroupWriter ResultErrorWriter => _cifFactory.GetLorryErrorResultWriter(); + + public override ICifSummaryWriter SummaryWriter => _cifFactory.GetLorryPEVSummaryWriter(); + + } + + public class ConventionalBus : AbstractResultsWriter + { + public ConventionalBus(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + protected override IResultGroupWriter ResultSuccessWriter => null; + protected override IResultGroupWriter ResultErrorWriter => null; + + public override ICifSummaryWriter SummaryWriter => null; + + } + + public class HEVNonOVCBus : AbstractResultsWriter + { + public HEVNonOVCBus(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + protected override IResultGroupWriter ResultSuccessWriter => null; + protected override IResultGroupWriter ResultErrorWriter => null; + + public override ICifSummaryWriter SummaryWriter => null; + + } + + public class HEVOVCBus : AbstractResultsWriter + { + public HEVOVCBus(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + public override XElement GenerateResults(List<IResultEntry> results) + { + var ordered = GetOrderedResultsOVC(results); + var allSuccess = results.All(x => x.Status == VectoRun.Status.Success); + return new XElement(Cif + "Results", + new XElement(Cif + 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 => _cifFactory.GetBusOVCSuccessResultWriter(); + protected override IResultGroupWriter ResultErrorWriter => _cifFactory.GetBusOVCErrorResultWriter(); + + public override ICifSummaryWriter SummaryWriter => _cifFactory.GetBusOVCCifSummaryWriter(); + + } + + public class PEVBus : AbstractResultsWriter + { + public PEVBus(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + protected override IResultGroupWriter ResultSuccessWriter => null; + protected override IResultGroupWriter ResultErrorWriter => null; + public override ICifSummaryWriter SummaryWriter => null; + + } + + public class ExemptedResultsWriter : AbstractResultsWriter + { + public ExemptedResultsWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Implementation of IResultsWriter + + public override XElement GenerateResults(List<IResultEntry> results) + { + return new XElement(Cif + "Results", + new XElement(Cif + "Status", "success"), + new XElement(Cif + "ExemptedVehicle")); + } + + protected override IResultGroupWriter ResultSuccessWriter => null; + protected override IResultGroupWriter ResultErrorWriter => null; + public override ICifSummaryWriter SummaryWriter => null; + + + #endregion + + + } + } +} \ No newline at end of file diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/CO2Writer.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/CO2Writer.cs index bcd6e0220413c6f70519da5abefaffae8ecc1659..f636b2d838cb40b4501b4a6a88a600ae10f163c5 100644 --- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/CO2Writer.cs +++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/CO2Writer.cs @@ -11,28 +11,19 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation { protected CO2WriterBase(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - #region Implementation of IFuelConsumptionWriter - - public XElement[] GetElement(IResultEntry entry) + public XElement[] GetElements(IResultEntry entry) { - return GetFuelConsumption(entry.CO2Total, entry.Distance, entry.Payload, entry.CargoVolume, entry.PassengerCount).Select(x => + return GetCO2ResultEntries(entry.CO2Total, entry.Distance, entry.Payload, entry.CargoVolume, entry.PassengerCount).Select(x => new XElement(Cif + XMLNames.Report_Results_CO2, XMLHelper.ValueAsUnit(x, 3, 1))).ToArray(); } - protected abstract IList<ConvertedSI> GetFuelConsumption(Kilogram co2, Meter distance, Kilogram payload, CubicMeter volume, double? passengers); - - #endregion - - #region Overrides of AbstractResultWriter - - public virtual XElement[] GetElement(IOVCResultEntry ovcEntry) + public virtual XElement[] GetElements(IWeightedResult entry) { - var entry = ovcEntry.Weighted; - return GetFuelConsumption(entry.CO2Total, entry.Distance, entry.Payload, entry.CargoVolume, entry.PassengerCount).Select(x => + return GetCO2ResultEntries(entry.CO2Total, entry.Distance, entry.Payload, entry.CargoVolume, entry.PassengerCount).Select(x => new XElement(Cif + XMLNames.Report_Results_CO2, XMLHelper.ValueAsUnit(x, 3, 1))).ToArray(); } - #endregion + protected abstract IList<ConvertedSI> GetCO2ResultEntries(Kilogram co2, Meter distance, Kilogram payload, CubicMeter volume, double? passengers); } @@ -41,9 +32,7 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation public LorryCO2Writer(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - #region Overrides of FuelConsumptionWriterBase - - protected override IList<ConvertedSI> GetFuelConsumption(Kilogram CO2Total, Meter distance, Kilogram payload, CubicMeter volume, double? passengers) + protected override IList<ConvertedSI> GetCO2ResultEntries(Kilogram CO2Total, Meter distance, Kilogram payload, CubicMeter volume, double? passengers) { return new[] { (CO2Total / distance).ConvertToGrammPerKiloMeter(), @@ -52,17 +41,13 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation }; } - #endregion } public class BusCO2Writer : CO2WriterBase { public BusCO2Writer(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - - #region Overrides of FuelConsumptionWriterBase - - protected override IList<ConvertedSI> GetFuelConsumption(Kilogram CO2Total, Meter distance, Kilogram payload, CubicMeter volume, double? passengers) + protected override IList<ConvertedSI> GetCO2ResultEntries(Kilogram CO2Total, Meter distance, Kilogram payload, CubicMeter volume, double? passengers) { return new[] { (CO2Total / distance).ConvertToGrammPerKiloMeter(), @@ -70,6 +55,5 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation }; } - #endregion } } \ No newline at end of file diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/ElectricEnergyWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/ElectricEnergyWriter.cs index 8f741e25e17c7d49766f3c06d84b6c27e140874c..d830d1dfd88afe41f0dc78ca5e481fbf5e8e4145 100644 --- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/ElectricEnergyWriter.cs +++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/ElectricEnergyWriter.cs @@ -9,13 +9,13 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation ResultWriter { - public abstract class ElectricEnergyConsumptionWriterBase : AbstractResultGroupWriter + public abstract class ElectricEnergyConsumptionWriterBase : AbstractResultWriter, IElectricEnergyConsumptionWriter { public ElectricEnergyConsumptionWriterBase(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } #region Overrides of AbstractResultWriter - public override XElement GetElement(IResultEntry entry) + public virtual XElement GetElement(IResultEntry entry) { return new XElement(Cif + "ElectricEnergy", GetEnergyConsumption(entry.ElectricEnergyConsumption, entry.Distance, entry.Payload, entry.CargoVolume, @@ -24,12 +24,11 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation ); } - public override XElement GetElement(IOVCResultEntry ovcEntry) + public virtual XElement GetElement(IWeightedResult weighted) { - var entry = ovcEntry.Weighted; return new XElement(Cif + "ElectricEnergy", - GetEnergyConsumption(entry.ElectricEnergyConsumption, entry.Distance, entry.Payload, entry.CargoVolume, - entry.PassengerCount).Select(x => + GetEnergyConsumption(weighted.ElectricEnergyConsumption, weighted.Distance, weighted.Payload, weighted.CargoVolume, + weighted.PassengerCount).Select(x => new XElement(Cif + XMLNames.Report_Result_EnergyConsumption, XMLHelper.ValueAsUnit(x, 3, 1))) ); diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/FuelConsumptionWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/FuelConsumptionWriter.cs index 4a805402cf286263cf096569fafe2db6ef759aaf..cbac686237fda409b6e26b61feb5d407be10cf07 100644 --- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/FuelConsumptionWriter.cs +++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/FuelConsumptionWriter.cs @@ -10,7 +10,7 @@ using TUGraz.VectoCore.Utils; namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformationFile.CustomerInformationFile_0_9.ResultWriter { - public abstract class FuelConsumptionWriterBase : AbstractResultGroupWriter, IFuelConsumptionWriter + public abstract class FuelConsumptionWriterBase : AbstractResultWriter, IFuelConsumptionWriter { protected FuelConsumptionWriterBase(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } @@ -20,7 +20,7 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation { return new XElement(Cif + XMLNames.Report_Results_Fuel, new XAttribute(XMLNames.Report_Results_Fuel_Type_Attr, fc.Fuel.FuelType.ToXMLFormat()), - GetFuelConsumption(fc.TotalFuelConsumptionCorrected, fc.Fuel, entry.Distance, entry.Payload, entry.CargoVolume, entry.PassengerCount).Select(x => new XElement(Cif + XMLNames.Report_Results_FuelConsumption, XMLHelper.ValueAsUnit(x, 3, 1))) + GetFuelConsumptionEntries(fc.TotalFuelConsumptionCorrected, fc.Fuel, entry.Distance, entry.Payload, entry.CargoVolume, entry.PassengerCount).Select(x => new XElement(Cif + XMLNames.Report_Results_FuelConsumption, XMLHelper.ValueAsUnit(x, 3, 1))) ); } @@ -28,25 +28,16 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation { return new XElement(Cif + XMLNames.Report_Results_Fuel, new XAttribute(XMLNames.Report_Results_Fuel_Type_Attr, fuel.FuelType.ToXMLFormat()), - GetFuelConsumption(consumption, fuel, entry.Distance, entry.Payload, entry.CargoVolume, entry.PassengerCount).Select(x => new XElement(Cif + XMLNames.Report_Results_FuelConsumption, XMLHelper.ValueAsUnit(x, 3, 1))) + GetFuelConsumptionEntries(consumption, fuel, entry.Distance, entry.Payload, entry.CargoVolume, entry.PassengerCount).Select(x => new XElement(Cif + XMLNames.Report_Results_FuelConsumption, XMLHelper.ValueAsUnit(x, 3, 1))) ); } - protected abstract IList<ConvertedSI> GetFuelConsumption(Kilogram fc, + protected abstract IList<ConvertedSI> GetFuelConsumptionEntries(Kilogram fc, IFuelProperties fuel, Meter distance, Kilogram payload, CubicMeter volume, double? passenger); #endregion - #region Overrides of AbstractResultWriter - - public override XElement GetElement(IResultEntry entry) - { - throw new NotImplementedException(); - } - - #endregion - } public class LorryFuelConsumptionWriter : FuelConsumptionWriterBase @@ -56,7 +47,7 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation #region Overrides of FuelConsumptionWriterBase - protected override IList<ConvertedSI> GetFuelConsumption(Kilogram fc, IFuelProperties fuel, Meter distance, Kilogram payload, CubicMeter volume, double? passenger) + protected override IList<ConvertedSI> GetFuelConsumptionEntries(Kilogram fc, IFuelProperties fuel, Meter distance, Kilogram payload, CubicMeter volume, double? passenger) { var retVal = new List<ConvertedSI> { (fc / distance).ConvertToGrammPerKiloMeter(), @@ -89,7 +80,7 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation #region Overrides of FuelConsumptionWriterBase - protected override IList<ConvertedSI> GetFuelConsumption(Kilogram fc, IFuelProperties fuel, Meter distance, Kilogram payload, CubicMeter volume, double? passenger) + protected override IList<ConvertedSI> GetFuelConsumptionEntries(Kilogram fc, IFuelProperties fuel, Meter distance, Kilogram payload, CubicMeter volume, double? passenger) { var retVal = new List<ConvertedSI> { (fc / distance).ConvertToGrammPerKiloMeter(), diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/IResultsWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/IResultsWriter.cs index 624cf0dba3c901aeaa3ae79d7cd7762fbf4f7c3f..ad190c07ea882091406edfb667c14de7513236ec 100644 --- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/IResultsWriter.cs +++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/IResultsWriter.cs @@ -33,11 +33,18 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation } + public interface IElectricEnergyConsumptionWriter + { + XElement GetElement(IResultEntry entry); + + XElement GetElement(IWeightedResult weighted); + } + public interface ICO2Writer { - XElement[] GetElement(IResultEntry entry); + XElement[] GetElements(IResultEntry entry); - XElement[] GetElement(IOVCResultEntry entry); + XElement[] GetElements(IWeightedResult entry); } public interface ICifSummaryWriter @@ -47,217 +54,66 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation XElement GetElement(IList<IOVCResultEntry> entries); } + public interface IElectricRangeWriter + { + XElement[] GetElements(IResultEntry weightedResult); + + XElement[] GetElements(IWeightedResult weightedResult); + + } + public interface ICifResultsWriterFactory { - IResultGroupWriter GetLorryOVCSuccessResultWriter(); - IResultGroupWriter GetLorryOVCErrorResultWriter(); + IResultGroupWriter GetLorryConvSuccessResultWriter(); + IResultGroupWriter GetLorryHEVNonOVCSuccessResultWriter(); + IResultGroupWriter GetLorryHEVOVCSuccessResultWriter(); + IResultGroupWriter GetLorryPEVSuccessResultWriter(); + + IResultGroupWriter GetLorryErrorResultWriter(); + + IResultGroupWriter GetBusSuccessResultWriter(); IResultGroupWriter GetBusOVCSuccessResultWriter(); + IResultGroupWriter GetBusErrorResultWriter(); IResultGroupWriter GetBusOVCErrorResultWriter(); IResultGroupWriter GetMissionWriter(); IResultGroupWriter GetLorrySimulationParameterWriter(); - IResultGroupWriter GetLorryOVCResultWriterChargeDepleting(); - IResultGroupWriter GetLorryOVCResultWriterChargeSustaining(); - IResultGroupWriter GetLorryOVCSummaryWriter(); + + IResultGroupWriter GetLorryConvTotalWriter(); + IResultGroupWriter GetLorryHEVNonOVCTotalWriter(); + IResultGroupWriter GetLorryHEVOVCResultWriterChargeDepleting(); + IResultGroupWriter GetLorryHEVOVCResultWriterChargeSustaining(); + IResultGroupWriter GetLorryHEVOVCTotalWriter(); + IResultGroupWriter GetLorryPEVTotalWriter(); + IFuelConsumptionWriter GetFuelConsumptionLorry(); - IResultGroupWriter GetElectricEnergyConsumptionLorry(); + IElectricEnergyConsumptionWriter GetElectricEnergyConsumptionLorry(); ICO2Writer GetCO2ResultLorry(); - ICifSummaryWriter GetLorryOVCCifSummaryWriter(); + ICifSummaryWriter GetLorryConvSummaryWriter(); + ICifSummaryWriter GetLorryHEVNonOVCSummaryWriter(); + ICifSummaryWriter GetLorryHEVOVCSummaryWriter(); + ICifSummaryWriter GetLorryPEVSummaryWriter(); IResultGroupWriter GetBusSimulationParameterWriter(); IResultGroupWriter GetBusOVCResultWriterChargeDepleting(); IResultGroupWriter GetBusOVCResultWriterChargeSustaining(); - IResultGroupWriter GetBusOVCSummaryWriter(); + IResultGroupWriter GetBusOVCTotalWriter(); IFuelConsumptionWriter GetFuelConsumptionBus(); - IResultGroupWriter GetElectricEnergyConsumptionBus(); + IElectricEnergyConsumptionWriter GetElectricEnergyConsumptionBus(); ICO2Writer GetCO2ResultBus(); ICifSummaryWriter GetBusOVCCifSummaryWriter(); - } + IElectricRangeWriter GetElectricRangeWriter(); - public abstract class AbstractResultsWriter : IResultsWriter - { - protected static readonly XNamespace Cif = "urn:tugraz:ivt:VectoAPI:CustomerOutput:v0.9"; - - protected readonly ICifResultsWriterFactory _cifFactory; - - protected AbstractResultsWriter(ICifResultsWriterFactory cifFactory) - { - _cifFactory = cifFactory; - } - - #region Implementation of IResultsWriter - - //public abstract XElement GenerateResults(List<IResultEntry> results); - - public virtual XElement GenerateResults(List<IResultEntry> results) - { - return null; - } - - #endregion - - protected List<IOVCResultEntry> GetOrderedResultsOVC(List<IResultEntry> results) - { - if (!results.All(x => x.OVCMode.IsOneOf(VectoRunData.OvcHevMode.ChargeSustaining, VectoRunData.OvcHevMode.ChargeDepleting))) { - throw new VectoException( - "Simulation runs for OVC vehicles must be either Charge Sustaining or Charge Depleting!"); - } - - var retVal = new List<IOVCResultEntry>(results.Count / 2); - var cdEntries = results.Where(x => x.OVCMode == VectoRunData.OvcHevMode.ChargeSustaining) - .OrderBy(x => x.VehicleClass) - .ThenBy(x => x.FuelMode) - .ThenBy(x => x.Mission) - .ThenBy(x => x.LoadingType) - .ToList(); - foreach (var cdEntry in cdEntries) { - var csEntry = results.FirstOrDefault(x => x.OVCMode != cdEntry.OVCMode && - x.VehicleClass == cdEntry.VehicleClass && - x.FuelMode == cdEntry.FuelMode && - x.Mission == cdEntry.Mission && - x.LoadingType == cdEntry.LoadingType); - if (csEntry == null) { - throw new VectoException( - $"no matching result for {cdEntry.Mission}, {cdEntry.LoadingType}, {cdEntry.FuelMode} found!"); - } - - var combined = new OvcResultEntry() { - ChargeSustainingResult = csEntry, - ChargeDepletingResult = cdEntry, - Weighted = DeclarationData.CalculateWeightedResult(cdEntry, csEntry) - }; - retVal.Add(combined); - } - return retVal; - } - - //protected XElement GetSummary(List<IOVCResultEntry> orderedResults) - //{ - // var allSuccess = orderedResults.All(x => - // x.ChargeDepletingResult.Status == VectoRun.Status.Success && x.ChargeSustainingResult.Status == VectoRun.Status.Success); - // if (!allSuccess) { - // // do not write summary unless all simulation runs are successful! - // return null; - // } - - // return null; - // //return new XElement(Cif + "Summary", - // // new XElement(Cif + XMLNames.Report_ResultEntry_AverageSpeed, XMLHelper.ValueAsUnit())) - //} - - //protected XElement GetSummary(List<IResultEntry> results) - //{ - // var allSuccess = results.All(x => x.Status == VectoRun.Status.Success); - // if (!allSuccess) { - // // do not write summary unless all simulation runs are successful! - // return null; - // } - // throw new NotImplementedException(); - //} } - public class CIFResultsWriter - { - public class ConventionalLorry : AbstractResultsWriter - { - public ConventionalLorry(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - } - - public class HEVNonOVCLorry : AbstractResultsWriter - { - public HEVNonOVCLorry(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - } - - public class HEVOVCLorry : AbstractResultsWriter - { - #region Overrides of AbstractResultsWriter - - public override XElement GenerateResults(List<IResultEntry> results) - { - var ordered = GetOrderedResultsOVC(results); - var allSuccess = results.All(x => x.Status == VectoRun.Status.Success); - return new XElement(Cif + "Results", - new XElement(Cif + XMLNames.Report_Result_Status, allSuccess ? "success" : "error"), - ordered.Select(x => - x.ChargeDepletingResult.Status == VectoRun.Status.Success && - x.ChargeSustainingResult.Status == VectoRun.Status.Success - ? _cifFactory.GetLorryOVCSuccessResultWriter().GetElement(x) - : _cifFactory.GetLorryOVCErrorResultWriter().GetElement(x)), - _cifFactory.GetLorryOVCCifSummaryWriter().GetElement(ordered) - ); - } - - - - #endregion - - public HEVOVCLorry(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - } - - public class PEVLorry : AbstractResultsWriter - { - public PEVLorry(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - } - - public class ConventionalBus : AbstractResultsWriter - { - public ConventionalBus(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - } - - public class HEVNonOVCBus : AbstractResultsWriter - { - public HEVNonOVCBus(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - } - - public class HEVOVCBus : AbstractResultsWriter - { - public HEVOVCBus(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - - public override XElement GenerateResults(List<IResultEntry> results) - { - var ordered = GetOrderedResultsOVC(results); - var allSuccess = results.All(x => x.Status == VectoRun.Status.Success); - return new XElement(Cif + "Results", - new XElement(Cif + XMLNames.Report_Result_Status, allSuccess ? "success" : "error"), - ordered.Select(x => - x.ChargeDepletingResult.Status == VectoRun.Status.Success && - x.ChargeSustainingResult.Status == VectoRun.Status.Success - ? _cifFactory.GetBusOVCSuccessResultWriter().GetElement(x) - : _cifFactory.GetBusOVCErrorResultWriter().GetElement(x)), - _cifFactory.GetBusOVCCifSummaryWriter().GetElement(ordered) - ); - } - } - - public class PEVBus : AbstractResultsWriter - { - public PEVBus(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - } - - public class ExemptedResultsWriter : AbstractResultsWriter - { - - - #region Implementation of IResultsWriter - - public override XElement GenerateResults(List<IResultEntry> results) - { - return new XElement(Cif + "Results", - new XElement(Cif + "Status", "success"), - new XElement(Cif + "ExemptedVehicle")); - } - - #endregion - - public ExemptedResultsWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - } - } + + } \ No newline at end of file diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/ResultGoupWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/ResultGoupWriter.cs index 136c2c8a26d9a95dc1e7fc65f36019116ccc2f9c..6dac77a4f28e1f734f2b13e525cf7d612964a29b 100644 --- a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/ResultGoupWriter.cs +++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/ResultGoupWriter.cs @@ -36,13 +36,15 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation #region Implementation of IResultGroupWriter public abstract XElement GetElement(IResultEntry entry); + public virtual XElement GetElement(IOVCResultEntry entry) { throw new NotImplementedException(); } - #endregion + #endregion + } public class ErrorResultWriter : AbstractResultGroupWriter @@ -55,7 +57,7 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation public override XElement GetElement(IResultEntry entry) { if (entry.Status == VectoRun.Status.Success) { - throw new Exception("At least one entry needs to be unsuccessful!"); + throw new Exception("Siimulation run needs to be unsuccessful!"); } return new XElement(Cif + XMLNames.Report_Result_Result, new XAttribute(XMLNames.Report_Result_Status_Attr, "error"), @@ -118,208 +120,6 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation #endregion } - public class LorryOVCResultWriter : AbstractResultGroupWriter - { - - public LorryOVCResultWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - - #region Implementation of IResultGroupWriter - - public override XElement GetElement(IResultEntry entry) - { - throw new NotImplementedException(); - } - - public override XElement GetElement(IOVCResultEntry entry) - { - return new XElement(Cif + XMLNames.Report_Result_Result, - new XAttribute(XMLNames.Report_Result_Status_Attr, "success"), - new XAttribute(xsi + "type", "ResultSuccessOVCHEVType"), - _cifFactory.GetMissionWriter().GetElement(entry.ChargeDepletingResult), - _cifFactory.GetLorrySimulationParameterWriter().GetElement(entry.ChargeDepletingResult), - _cifFactory.GetLorryOVCResultWriterChargeDepleting().GetElement(entry.ChargeDepletingResult), - _cifFactory.GetLorryOVCResultWriterChargeSustaining().GetElement(entry.ChargeSustainingResult), - _cifFactory.GetLorryOVCSummaryWriter().GetElement(entry) - ); - } - - #endregion - } - - - public class LorryOVCChargeDepletingWriter : AbstractResultGroupWriter - { - public LorryOVCChargeDepletingWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - - #region Overrides of AbstractResultWriter - - public override XElement GetElement(IResultEntry entry) - { - return new XElement(Cif + "OVCMode", - new XAttribute("type", "charge depleting"), - new XElement(Cif + XMLNames.Report_ResultEntry_AverageSpeed, XMLHelper.ValueAsUnit(entry.AverageSpeed, XMLNames.Unit_kmph, 1)), - entry.FuelData.Select(f => - _cifFactory.GetFuelConsumptionLorry().GetElement(entry, entry.FuelConsumptionFinal(f.FuelType))), - _cifFactory.GetElectricEnergyConsumptionLorry().GetElement(entry), - _cifFactory.GetCO2ResultLorry().GetElement(entry) - ); - } - - - #endregion - } - - public class LorryOVCChargeSustainingWriter : AbstractResultGroupWriter - { - public LorryOVCChargeSustainingWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - - #region Overrides of AbstractResultWriter - - public override XElement GetElement(IResultEntry entry) - { - return new XElement(Cif + "OVCMode", - new XAttribute("type", "charge depleting"), - new XElement(Cif + XMLNames.Report_ResultEntry_AverageSpeed, XMLHelper.ValueAsUnit(entry.AverageSpeed, XMLNames.Unit_kmph, 1)), - entry.FuelData.Select(f => - _cifFactory.GetFuelConsumptionLorry().GetElement(entry, entry.FuelConsumptionFinal(f.FuelType))), - _cifFactory.GetCO2ResultLorry().GetElement(entry) - //GetCO2Result(entry) - ); - } - - #endregion - } - - - public abstract class OVCTotalWriterBase : AbstractResultGroupWriter - { - protected OVCTotalWriterBase(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - - #region Overrides of AbstractResultWriter - - public override XElement GetElement(IResultEntry entry) - { - throw new NotImplementedException(); - } - - public override XElement GetElement(IOVCResultEntry entry) - { - var total = entry.Weighted; - return new XElement(Cif + "Total", - new XElement(Cif + XMLNames.Report_ResultEntry_AverageSpeed, - XMLHelper.ValueAsUnit(total.AverageSpeed, "km/h", 1)), - GetFuelConsumption(entry), - GetElectricConsumption(entry), - GetCO2(entry), - new XElement(Cif + "ActualChargeDepletingRange", - XMLHelper.ValueAsUnit(total.ActualChargeDepletingRange.ConvertToKiloMeter())), - new XElement(Cif + "EquivalentAllElectricRange", - XMLHelper.ValueAsUnit(total.EquivalentAllElectricRange.ConvertToKiloMeter())), - new XElement(Cif + "ZeroCO2EmissionsRange", - XMLHelper.ValueAsUnit(total.ZeroCO2EmissionsRange.ConvertToKiloMeter())), - new XElement(Cif + "UtilityFactor", total.UtilityFactor.ToXMLFormat(3)) - ); - } - - protected abstract XElement[] GetFuelConsumption(IOVCResultEntry entry); - - #endregion - - protected abstract XElement GetElectricConsumption(IOVCResultEntry entry); - - protected abstract XElement[] GetCO2(IOVCResultEntry entry); - - } - - public class LorryOVCTotalWriter : OVCTotalWriterBase - { - public LorryOVCTotalWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - - #region Overrides of OVCSummaryWriterBase - - protected override XElement[] GetFuelConsumption(IOVCResultEntry entry) - { - return entry.Weighted.FuelConsumption.Select(e => - _cifFactory.GetFuelConsumptionLorry().GetElement(entry.Weighted, e.Key, e.Value)).ToArray(); - } - - protected override XElement GetElectricConsumption(IOVCResultEntry entry) - { - return _cifFactory.GetElectricEnergyConsumptionLorry().GetElement(entry); - } - - protected override XElement[] GetCO2(IOVCResultEntry entry) - { - return _cifFactory.GetCO2ResultLorry().GetElement(entry); - } - - #endregion - } - - - public abstract class CifSummaryWriterBase : AbstractResultWriter, ICifSummaryWriter - { - protected CifSummaryWriterBase(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - - #region Implementation of ICifSummaryWriter - - public XElement GetElement(IList<IResultEntry> entries) - { - var weighted = DeclarationData.CalculateWeightedSummary(entries); - //return new XElement( - // GetSummary(weighted), - // weighted.FuelConsumption.Select(x => _cifFactory.GetFuelConsumptionLorry().GetElement(weighted, x.Key, x.Value)), - // _cifFactory.GetElectricEnergyConsumptionLorry().GetElement(weighted), - // _cifFactory.GetCO2ResultLorry().GetElement(weighted), - // ); - return null; - } - - public XElement GetElement(IList<IOVCResultEntry> entries) - { - return null; - } - - #endregion - } - - public class LorryOVCCifSummaryWriter : CifSummaryWriterBase - { - public LorryOVCCifSummaryWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - } - - - // ----------------- - // bus - - public class BusOVCTotalWriter : AbstractResultGroupWriter - { - - public BusOVCTotalWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - - #region Implementation of IResultGroupWriter - - public override XElement GetElement(IResultEntry entry) - { - throw new NotImplementedException(); - } - - public override XElement GetElement(IOVCResultEntry entry) - { - return new XElement(Cif + XMLNames.Report_Result_Result, - new XAttribute(XMLNames.Report_Result_Status_Attr, "success"), - new XAttribute(xsi + "type", "ResultSuccessOVCHEVType"), - _cifFactory.GetMissionWriter().GetElement(entry.ChargeDepletingResult), - _cifFactory.GetBusSimulationParameterWriter().GetElement(entry.ChargeDepletingResult), - _cifFactory.GetBusOVCResultWriterChargeDepleting().GetElement(entry.ChargeDepletingResult), - _cifFactory.GetBusOVCResultWriterChargeSustaining().GetElement(entry.ChargeSustainingResult), - _cifFactory.GetBusOVCSummaryWriter().GetElement(entry) - ); - } - - #endregion - } - public class ResultSimulationParameterBusWriter : AbstractResultGroupWriter { public ResultSimulationParameterBusWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } @@ -341,74 +141,39 @@ namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformation #endregion } - public class BusOVCChargeDepletingWriter : AbstractResultGroupWriter + public class ElectricRangeWriter : AbstractResultWriter, IElectricRangeWriter { - public BusOVCChargeDepletingWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + public ElectricRangeWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - #region Overrides of AbstractResultWriter + #region Implementation of IElectricRangeWriter - public override XElement GetElement(IResultEntry entry) + public XElement[] GetElements(IResultEntry result) { - return new XElement(Cif + "OVCMode", - new XAttribute("type", "charge depleting"), - new XElement(Cif + XMLNames.Report_ResultEntry_AverageSpeed, XMLHelper.ValueAsUnit(entry.AverageSpeed, XMLNames.Unit_kmph, 1)), - entry.FuelData.Select(f => - _cifFactory.GetFuelConsumptionBus().GetElement(entry, entry.FuelConsumptionFinal(f.FuelType))), - _cifFactory.GetElectricEnergyConsumptionBus().GetElement(entry), - _cifFactory.GetCO2ResultBus().GetElement(entry) - ); + return new[] { + new XElement(Cif + "ActualChargeDepletingRange", + XMLHelper.ValueAsUnit(result.ActualChargeDepletingRange.ConvertToKiloMeter())), + new XElement(Cif + "EquivalentAllElectricRange", + XMLHelper.ValueAsUnit(result.EquivalentAllElectricRange.ConvertToKiloMeter())), + new XElement(Cif + "ZeroCO2EmissionsRange", + XMLHelper.ValueAsUnit(result.ZeroCO2EmissionsRange.ConvertToKiloMeter())), + }; } - #endregion - } - - public class BusOVCChargeSustainingWriter : AbstractResultGroupWriter - { - public BusOVCChargeSustainingWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - - #region Overrides of AbstractResultWriter - public override XElement GetElement(IResultEntry entry) + public XElement[] GetElements(IWeightedResult weightedResult) { - return new XElement(Cif + "OVCMode", - new XAttribute("type", "charge depleting"), - new XElement(Cif + XMLNames.Report_ResultEntry_AverageSpeed, XMLHelper.ValueAsUnit(entry.AverageSpeed, XMLNames.Unit_kmph, 1)), - entry.FuelData.Select(f => - _cifFactory.GetFuelConsumptionBus().GetElement(entry, entry.FuelConsumptionFinal(f.FuelType))), - _cifFactory.GetCO2ResultBus().GetElement(entry) - ); + return new[] { + new XElement(Cif + "ActualChargeDepletingRange", + XMLHelper.ValueAsUnit(weightedResult.ActualChargeDepletingRange.ConvertToKiloMeter())), + new XElement(Cif + "EquivalentAllElectricRange", + XMLHelper.ValueAsUnit(weightedResult.EquivalentAllElectricRange.ConvertToKiloMeter())), + new XElement(Cif + "ZeroCO2EmissionsRange", + XMLHelper.ValueAsUnit(weightedResult.ZeroCO2EmissionsRange.ConvertToKiloMeter())), + }; } #endregion } - public class BusOVCSummaryWriter : OVCTotalWriterBase - { - public BusOVCSummaryWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - - #region Overrides of OVCSummaryWriterBase - protected override XElement[] GetFuelConsumption(IOVCResultEntry entry) - { - return entry.Weighted.FuelConsumption.Select(e => - _cifFactory.GetFuelConsumptionBus().GetElement(entry.Weighted, e.Key, e.Value)).ToArray(); - } - - protected override XElement GetElectricConsumption(IOVCResultEntry entry) - { - return _cifFactory.GetElectricEnergyConsumptionBus().GetElement(entry); - } - - protected override XElement[] GetCO2(IOVCResultEntry entry) - { - return _cifFactory.GetCO2ResultBus().GetElement(entry); - } - - #endregion - } - - public class BusOVCCifSummaryWriter : CifSummaryWriterBase - { - public BusOVCCifSummaryWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } - } } diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/ResultTotalWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/ResultTotalWriter.cs new file mode 100644 index 0000000000000000000000000000000000000000..5d6f470a398cd59ace87182a52b8cfce16fbe871 --- /dev/null +++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/ResultTotalWriter.cs @@ -0,0 +1,196 @@ +using System; +using System.Linq; +using System.Xml.Linq; +using TUGraz.VectoCommon.Resources; +using TUGraz.VectoCommon.Utils; +using TUGraz.VectoCore.Utils; + +namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformationFile.CustomerInformationFile_0_9.ResultWriter +{ + public abstract class NonOVCTotalWriterBase : AbstractResultGroupWriter + { + protected NonOVCTotalWriterBase(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Overrides of AbstractResultWriter + + public override XElement GetElement(IResultEntry entry) + { + return new XElement(Cif + "Total", + new XElement(Cif + XMLNames.Report_ResultEntry_AverageSpeed, + XMLHelper.ValueAsUnit(entry.AverageSpeed, "km/h", 1)), + entry.FuelData.Select(f => + FuelConsumptionWriter?.GetElement(entry, entry.FuelConsumptionFinal(f.FuelType))), + ElectricEnergyConsumptionWriter?.GetElement(entry), + CO2Writer?.GetElements(entry), + ElectricRangeWriter?.GetElements(entry) + ); + } + + #endregion + + protected abstract IFuelConsumptionWriter FuelConsumptionWriter { get; } + + protected abstract IElectricEnergyConsumptionWriter ElectricEnergyConsumptionWriter { get; } + + protected abstract ICO2Writer CO2Writer { get; } + + protected abstract IElectricRangeWriter ElectricRangeWriter { get; } + + } + + public class LorryConvTotalWriter : NonOVCTotalWriterBase + { + public LorryConvTotalWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + + #region Overrides of NonOVCTotalWriterBase + + protected override IFuelConsumptionWriter FuelConsumptionWriter => _cifFactory.GetFuelConsumptionLorry(); + + protected override IElectricEnergyConsumptionWriter ElectricEnergyConsumptionWriter => null; + + protected override ICO2Writer CO2Writer => _cifFactory.GetCO2ResultLorry(); + + protected override IElectricRangeWriter ElectricRangeWriter => null; + + #endregion + } + + public class LorryHEVNonOVCTotalWriter : NonOVCTotalWriterBase + { + public LorryHEVNonOVCTotalWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + + #region Overrides of NonOVCTotalWriterBase + + protected override IFuelConsumptionWriter FuelConsumptionWriter => _cifFactory.GetFuelConsumptionLorry(); + + protected override IElectricEnergyConsumptionWriter ElectricEnergyConsumptionWriter => null; + + protected override ICO2Writer CO2Writer => _cifFactory.GetCO2ResultLorry(); + + protected override IElectricRangeWriter ElectricRangeWriter => null; + + #endregion + } + + public class LorryPEVTotalWriter : NonOVCTotalWriterBase + { + public LorryPEVTotalWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + + #region Overrides of NonOVCTotalWriterBase + + protected override IFuelConsumptionWriter FuelConsumptionWriter => null; + + protected override IElectricEnergyConsumptionWriter ElectricEnergyConsumptionWriter => _cifFactory.GetElectricEnergyConsumptionLorry(); + + protected override ICO2Writer CO2Writer => null; + + protected override IElectricRangeWriter ElectricRangeWriter => _cifFactory.GetElectricRangeWriter(); + + #endregion + } + + public abstract class OVCTotalWriterBase : AbstractResultGroupWriter + { + protected OVCTotalWriterBase(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Overrides of AbstractResultWriter + + public override XElement GetElement(IResultEntry entry) + { + throw new NotImplementedException(); + } + + public override XElement GetElement(IOVCResultEntry entry) + { + var total = entry.Weighted; + return new XElement(Cif + "Total", + new XElement(Cif + XMLNames.Report_ResultEntry_AverageSpeed, + XMLHelper.ValueAsUnit(total.AverageSpeed, "km/h", 1)), + GetFuelConsumption(entry), + GetElectricConsumption(entry), + GetCO2(entry), + _cifFactory.GetElectricRangeWriter().GetElements(total), + new XElement(Cif + "UtilityFactor", total.UtilityFactor.ToXMLFormat(3)) + ); + } + + protected abstract XElement[] GetFuelConsumption(IOVCResultEntry entry); + + #endregion + + protected abstract XElement GetElectricConsumption(IOVCResultEntry entry); + + protected abstract XElement[] GetCO2(IOVCResultEntry entry); + + } + + public class LorryHEVOVCTotalWriter : OVCTotalWriterBase + { + public LorryHEVOVCTotalWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Overrides of OVCSummaryWriterBase + + protected override XElement[] GetFuelConsumption(IOVCResultEntry entry) + { + return entry.Weighted.FuelConsumption.Select(e => + _cifFactory.GetFuelConsumptionLorry().GetElement(entry.Weighted, e.Key, e.Value)).ToArray(); + } + + protected override XElement GetElectricConsumption(IOVCResultEntry entry) + { + return _cifFactory.GetElectricEnergyConsumptionLorry().GetElement(entry.Weighted); + } + + protected override XElement[] GetCO2(IOVCResultEntry entry) + { + return _cifFactory.GetCO2ResultLorry().GetElements(entry.Weighted); + } + + #endregion + } + + + // ---- bus + + public class BusConvTotalWriter : NonOVCTotalWriterBase + { + public BusConvTotalWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Overrides of NonOVCTotalWriterBase + + protected override IFuelConsumptionWriter FuelConsumptionWriter { get; } + protected override IElectricEnergyConsumptionWriter ElectricEnergyConsumptionWriter { get; } + protected override ICO2Writer CO2Writer { get; } + protected override IElectricRangeWriter ElectricRangeWriter { get; } + + #endregion + } + + public class BusOVCTotalWriter : OVCTotalWriterBase + { + public BusOVCTotalWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Overrides of OVCSummaryWriterBase + + protected override XElement[] GetFuelConsumption(IOVCResultEntry entry) + { + return entry.Weighted.FuelConsumption.Select(e => + _cifFactory.GetFuelConsumptionBus().GetElement(entry.Weighted, e.Key, e.Value)).ToArray(); + } + + protected override XElement GetElectricConsumption(IOVCResultEntry entry) + { + return _cifFactory.GetElectricEnergyConsumptionBus().GetElement(entry.Weighted); + } + + protected override XElement[] GetCO2(IOVCResultEntry entry) + { + return _cifFactory.GetCO2ResultBus().GetElements(entry.Weighted); + } + + #endregion + } +} \ No newline at end of file diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/ResultWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/ResultWriter.cs new file mode 100644 index 0000000000000000000000000000000000000000..e3a09329ea333b554a82d278c8207fca6ccf15b2 --- /dev/null +++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/ResultWriter.cs @@ -0,0 +1,251 @@ +using System; +using System.Linq; +using System.Xml.Linq; +using TUGraz.VectoCommon.Resources; +using TUGraz.VectoCore.Utils; + +namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformationFile.CustomerInformationFile_0_9.ResultWriter +{ + public abstract class CIFResultWriterBase : AbstractResultGroupWriter + { + protected CIFResultWriterBase(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Overrides of AbstractResultGroupWriter + + public override XElement GetElement(IResultEntry entry) + { + return new XElement(Cif + XMLNames.Report_Result_Result, + new XAttribute(XMLNames.Report_Result_Status_Attr, "success"), + new XAttribute(xsi + "type", ResultXMLType), + _cifFactory.GetMissionWriter().GetElement(entry), + SimulationParameterWriter.GetElement(entry), + ResultTotalWriter.GetElement(entry) + ); + } + #endregion + + public abstract string ResultXMLType { get; } + + public abstract IResultGroupWriter SimulationParameterWriter { get; } + public abstract IResultGroupWriter ResultTotalWriter { get; } + } + + public class LorryConvResultWriter : CIFResultWriterBase + { + + public LorryConvResultWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + public override string ResultXMLType => "ResultSuccessConventionalType"; + public override IResultGroupWriter SimulationParameterWriter => _cifFactory.GetLorrySimulationParameterWriter(); + public override IResultGroupWriter ResultTotalWriter => _cifFactory.GetLorryConvTotalWriter(); + + + } + + public class LorryHEVNonOVCResultWriter : CIFResultWriterBase + { + + public LorryHEVNonOVCResultWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + public override string ResultXMLType => "ResultSuccessNonOVCHEVType"; + public override IResultGroupWriter SimulationParameterWriter => _cifFactory.GetLorrySimulationParameterWriter(); + public override IResultGroupWriter ResultTotalWriter => _cifFactory.GetLorryHEVNonOVCTotalWriter(); + + + } + + public class LorryPEVResultWriter : CIFResultWriterBase + { + + public LorryPEVResultWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + public override string ResultXMLType => "ResultSuccessPEVType"; + public override IResultGroupWriter SimulationParameterWriter => _cifFactory.GetLorrySimulationParameterWriter(); + public override IResultGroupWriter ResultTotalWriter => _cifFactory.GetLorryPEVTotalWriter(); + + + } + + public class LorryHEVOVCResultWriter : AbstractResultGroupWriter + { + + public LorryHEVOVCResultWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Implementation of IResultGroupWriter + + public override XElement GetElement(IResultEntry entry) + { + throw new NotImplementedException(); + } + + public override XElement GetElement(IOVCResultEntry entry) + { + return new XElement(Cif + XMLNames.Report_Result_Result, + new XAttribute(XMLNames.Report_Result_Status_Attr, "success"), + new XAttribute(xsi + "type", "ResultSuccessOVCHEVType"), + _cifFactory.GetMissionWriter().GetElement(entry.ChargeDepletingResult), + _cifFactory.GetLorrySimulationParameterWriter().GetElement(entry.ChargeDepletingResult), + _cifFactory.GetLorryHEVOVCResultWriterChargeDepleting().GetElement(entry.ChargeDepletingResult), + _cifFactory.GetLorryHEVOVCResultWriterChargeSustaining().GetElement(entry.ChargeSustainingResult), + _cifFactory.GetLorryHEVOVCTotalWriter().GetElement(entry) + ); + } + + #endregion + } + + public class LorryHEVOVCChargeDepletingWriter : AbstractResultGroupWriter + { + public LorryHEVOVCChargeDepletingWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Overrides of AbstractResultWriter + + public override XElement GetElement(IResultEntry entry) + { + return new XElement(Cif + "OVCMode", + new XAttribute("type", "charge depleting"), + new XElement(Cif + XMLNames.Report_ResultEntry_AverageSpeed, XMLHelper.ValueAsUnit(entry.AverageSpeed, XMLNames.Unit_kmph, 1)), + entry.FuelData.Select(f => + _cifFactory.GetFuelConsumptionLorry().GetElement(entry, entry.FuelConsumptionFinal(f.FuelType))), + _cifFactory.GetElectricEnergyConsumptionLorry().GetElement(entry), + _cifFactory.GetCO2ResultLorry().GetElements(entry) + ); + } + + + #endregion + } + + public class LorryHEVOVCChargeSustainingWriter : AbstractResultGroupWriter + { + public LorryHEVOVCChargeSustainingWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Overrides of AbstractResultWriter + + public override XElement GetElement(IResultEntry entry) + { + return new XElement(Cif + "OVCMode", + new XAttribute("type", "charge depleting"), + new XElement(Cif + XMLNames.Report_ResultEntry_AverageSpeed, XMLHelper.ValueAsUnit(entry.AverageSpeed, XMLNames.Unit_kmph, 1)), + entry.FuelData.Select(f => + _cifFactory.GetFuelConsumptionLorry().GetElement(entry, entry.FuelConsumptionFinal(f.FuelType))), + _cifFactory.GetCO2ResultLorry().GetElements(entry) + ); + } + + #endregion + } + + + + // ----- bus + + public class BusConvResultWriter : CIFResultWriterBase + { + public BusConvResultWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Overrides of CIFResultWriterBase + + public override string ResultXMLType { get; } + public override IResultGroupWriter SimulationParameterWriter { get; } + public override IResultGroupWriter ResultTotalWriter { get; } + + #endregion + } + + public class BusHEVNonOVCResultWriter : CIFResultWriterBase + { + public BusHEVNonOVCResultWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Overrides of CIFResultWriterBase + + public override string ResultXMLType { get; } + public override IResultGroupWriter SimulationParameterWriter { get; } + public override IResultGroupWriter ResultTotalWriter { get; } + + #endregion + } + + public class BusPEVResultWriter : CIFResultWriterBase + { + public BusPEVResultWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Overrides of CIFResultWriterBase + + public override string ResultXMLType { get; } + public override IResultGroupWriter SimulationParameterWriter { get; } + public override IResultGroupWriter ResultTotalWriter { get; } + + #endregion + } + + + public class BusHEVOVCResultWriter : AbstractResultGroupWriter + { + + public BusHEVOVCResultWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Implementation of IResultGroupWriter + + public override XElement GetElement(IResultEntry entry) + { + throw new NotImplementedException(); + } + + public override XElement GetElement(IOVCResultEntry entry) + { + return new XElement(Cif + XMLNames.Report_Result_Result, + new XAttribute(XMLNames.Report_Result_Status_Attr, "success"), + new XAttribute(xsi + "type", "ResultSuccessOVCHEVType"), + _cifFactory.GetMissionWriter().GetElement(entry.ChargeDepletingResult), + _cifFactory.GetBusSimulationParameterWriter().GetElement(entry.ChargeDepletingResult), + _cifFactory.GetBusOVCResultWriterChargeDepleting().GetElement(entry.ChargeDepletingResult), + _cifFactory.GetBusOVCResultWriterChargeSustaining().GetElement(entry.ChargeSustainingResult), + _cifFactory.GetBusOVCTotalWriter().GetElement(entry) + ); + } + + #endregion + + } + + public class BusOVCChargeDepletingWriter : AbstractResultGroupWriter + { + public BusOVCChargeDepletingWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Overrides of AbstractResultWriter + + public override XElement GetElement(IResultEntry entry) + { + return new XElement(Cif + "OVCMode", + new XAttribute("type", "charge depleting"), + new XElement(Cif + XMLNames.Report_ResultEntry_AverageSpeed, XMLHelper.ValueAsUnit(entry.AverageSpeed, XMLNames.Unit_kmph, 1)), + entry.FuelData.Select(f => + _cifFactory.GetFuelConsumptionBus().GetElement(entry, entry.FuelConsumptionFinal(f.FuelType))), + _cifFactory.GetElectricEnergyConsumptionBus().GetElement(entry), + _cifFactory.GetCO2ResultBus().GetElements(entry) + ); + } + #endregion + } + + public class BusOVCChargeSustainingWriter : AbstractResultGroupWriter + { + public BusOVCChargeSustainingWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Overrides of AbstractResultWriter + + public override XElement GetElement(IResultEntry entry) + { + return new XElement(Cif + "OVCMode", + new XAttribute("type", "charge depleting"), + new XElement(Cif + XMLNames.Report_ResultEntry_AverageSpeed, XMLHelper.ValueAsUnit(entry.AverageSpeed, XMLNames.Unit_kmph, 1)), + entry.FuelData.Select(f => + _cifFactory.GetFuelConsumptionBus().GetElement(entry, entry.FuelConsumptionFinal(f.FuelType))), + _cifFactory.GetCO2ResultBus().GetElements(entry) + ); + } + + #endregion + } +} \ No newline at end of file diff --git a/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/SummaryWriter.cs b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/SummaryWriter.cs new file mode 100644 index 0000000000000000000000000000000000000000..970543c5587bb266ea6b3933daa6bb6ee634f3a7 --- /dev/null +++ b/VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/SummaryWriter.cs @@ -0,0 +1,151 @@ +using System.Collections.Generic; +using System.Linq; +using System.Xml.Linq; +using TUGraz.VectoCommon.Resources; +using TUGraz.VectoCommon.Utils; +using TUGraz.VectoCore.Models.Declaration; +using TUGraz.VectoCore.Utils; + +namespace TUGraz.VectoCore.OutputData.XML.DeclarationReports.CustomerInformationFile.CustomerInformationFile_0_9.ResultWriter +{ + public abstract class CifSummaryWriterBase : AbstractResultWriter, ICifSummaryWriter + { + protected CifSummaryWriterBase(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Implementation of ICifSummaryWriter + + public XElement GetElement(IList<IResultEntry> entries) + { + var weighted = DeclarationData.CalculateWeightedSummary(entries); + return DoGetElement(weighted); + } + + public XElement GetElement(IList<IOVCResultEntry> entries) + { + var weighted = DeclarationData.CalculateWeightedSummary(entries); + return DoGetElement(weighted); + } + + protected virtual XElement DoGetElement(IWeightedResult weighted) + { + return new XElement(Cif + XMLNames.Report_Results_Summary, + new XAttribute(xsi + XMLNames.XSIType, ResultSummaryXMLType), + GetSummary(weighted), + weighted.FuelConsumption.Select(x => + FuelConsumptionWriter?.GetElement(weighted, x.Key, x.Value)).ToArray(), + ElectricEnergyConsumptionWriter?.GetElement(weighted), + CO2Writer?.GetElements(weighted), + ElectricRangeWriter?.GetElements(weighted) + ); + } + + public abstract string ResultSummaryXMLType { get; } + + + protected abstract XElement[] GetSummary(IWeightedResult weighted); + + protected abstract IFuelConsumptionWriter FuelConsumptionWriter { get; } + + protected abstract IElectricEnergyConsumptionWriter ElectricEnergyConsumptionWriter { get; } + + protected abstract ICO2Writer CO2Writer { get; } + + protected abstract IElectricRangeWriter ElectricRangeWriter { get; } + + #endregion + } + + public abstract class LorrySummaryWriterBase : CifSummaryWriterBase + { + protected LorrySummaryWriterBase(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + protected override XElement[] GetSummary(IWeightedResult weighted) + { + return new[] { + new XElement(Cif + "AveragePayload", XMLHelper.ValueAsUnit(weighted.Payload, "t")) + }; + } + } + + public class LorryConvSummaryWriter : LorrySummaryWriterBase + { + public LorryConvSummaryWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + public override string ResultSummaryXMLType => "ResultSummaryConventionalType"; + protected override IFuelConsumptionWriter FuelConsumptionWriter => _cifFactory.GetFuelConsumptionLorry(); + protected override IElectricEnergyConsumptionWriter ElectricEnergyConsumptionWriter => null; + protected override ICO2Writer CO2Writer => _cifFactory.GetCO2ResultLorry(); + protected override IElectricRangeWriter ElectricRangeWriter => null; + + } + + public class LorryHEVNonOVCSummaryWriter : LorrySummaryWriterBase + { + public LorryHEVNonOVCSummaryWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + public override string ResultSummaryXMLType => "ResultSummaryNonOVCHEVType"; + protected override IFuelConsumptionWriter FuelConsumptionWriter => _cifFactory.GetFuelConsumptionLorry(); + protected override IElectricEnergyConsumptionWriter ElectricEnergyConsumptionWriter => null; + protected override ICO2Writer CO2Writer => _cifFactory.GetCO2ResultLorry(); + protected override IElectricRangeWriter ElectricRangeWriter => null; + + } + + public class LorryHEVOVCSummaryWriter : LorrySummaryWriterBase + { + public LorryHEVOVCSummaryWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + #region Overrides of CifSummaryWriterBase + + public override string ResultSummaryXMLType => "ResultSummaryOVCHEVType"; + protected override IFuelConsumptionWriter FuelConsumptionWriter => _cifFactory.GetFuelConsumptionLorry(); + protected override IElectricEnergyConsumptionWriter ElectricEnergyConsumptionWriter => _cifFactory.GetElectricEnergyConsumptionLorry(); + protected override ICO2Writer CO2Writer => _cifFactory.GetCO2ResultLorry(); + protected override IElectricRangeWriter ElectricRangeWriter => _cifFactory.GetElectricRangeWriter(); + + #endregion + } + + public class LorryPEVSummaryWriter : LorrySummaryWriterBase + { + public LorryPEVSummaryWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + public override string ResultSummaryXMLType => "ResultSummaryPEVType"; + protected override IFuelConsumptionWriter FuelConsumptionWriter => null; + protected override IElectricEnergyConsumptionWriter ElectricEnergyConsumptionWriter => _cifFactory.GetElectricEnergyConsumptionLorry(); + protected override ICO2Writer CO2Writer => null; + protected override IElectricRangeWriter ElectricRangeWriter => _cifFactory.GetElectricRangeWriter(); + + } + + // ---- bus + + public abstract class BusSummaryWriterBase : CifSummaryWriterBase + { + protected BusSummaryWriterBase(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + protected override XElement[] GetSummary(IWeightedResult weighted) + { + return new[] { + new XElement(Cif + "AveragePassengerCount", weighted.PassengerCount.Value.ToXMLFormat(2)) + }; + } + } + + public class BusOVCCifSummaryWriter : BusSummaryWriterBase + { + public BusOVCCifSummaryWriter(ICifResultsWriterFactory cifFactory) : base(cifFactory) { } + + + #region Overrides of CifSummaryWriterBase + + public override string ResultSummaryXMLType => "ResultSummaryOVCHEVType"; + protected override IFuelConsumptionWriter FuelConsumptionWriter => _cifFactory.GetFuelConsumptionBus(); + + protected override IElectricEnergyConsumptionWriter ElectricEnergyConsumptionWriter => _cifFactory.GetElectricEnergyConsumptionBus(); + protected override ICO2Writer CO2Writer => _cifFactory.GetCO2ResultBus(); + protected override IElectricRangeWriter ElectricRangeWriter => _cifFactory.GetElectricRangeWriter(); + + #endregion + } +} \ No newline at end of file diff --git a/VectoCore/VectoCore/OutputData/XML/XMLDeclarationReport.cs b/VectoCore/VectoCore/OutputData/XML/XMLDeclarationReport.cs index 9a9ab06805bf1eb4f45ca4c54d2ce974c114655e..145bb8b7fdc602639b77b6639b0c34c5402e39d2 100644 --- a/VectoCore/VectoCore/OutputData/XML/XMLDeclarationReport.cs +++ b/VectoCore/VectoCore/OutputData/XML/XMLDeclarationReport.cs @@ -135,6 +135,9 @@ namespace TUGraz.VectoCore.OutputData.XML public double AverageAxlegearEfficiency { get; private set; } public double WeightingFactor { get; set; } + public Meter ActualChargeDepletingRange { get; set; } + public Meter EquivalentAllElectricRange { get; set; } + public Meter ZeroCO2EmissionsRange { get; set; } public VectoRunData.OvcHevMode OVCMode { get; set; } @@ -180,6 +183,10 @@ namespace TUGraz.VectoCore.OutputData.XML EnergyConsumptionTotal = data.CorrectedModalData.FuelEnergyConsumptionTotal; ElectricEnergyConsumption = data.CorrectedModalData.ElectricEnergyConsumption; + if (runData.JobType.IsOneOf(VectoSimulationJobType.BatteryElectricVehicle, + VectoSimulationJobType.IEPC_E)) { + DeclarationData.SetElectricRangesPEV(this, runData, data); + } var gbxOutSignal = runData.Retarder.Type == RetarderType.TransmissionOutputRetarder ? ModalResultField.P_retarder_in diff --git a/VectoCore/VectoCoreTest/Reports/TestXMLResultsWriting.cs b/VectoCore/VectoCoreTest/Reports/TestXMLResultsWriting.cs index 155d37952ae866a3a024ffdb117331494ea26997..c62a3747ebb4472186beffbf03512acd9786b659 100644 --- a/VectoCore/VectoCoreTest/Reports/TestXMLResultsWriting.cs +++ b/VectoCore/VectoCoreTest/Reports/TestXMLResultsWriting.cs @@ -63,10 +63,20 @@ public class TestXMLResultsWriting [ + TestCase(VectoSimulationJobType.ConventionalVehicle, false, false, true, TestName = "ReportResult_WritingResults: Lorry Conv SUCCESS"), + TestCase(VectoSimulationJobType.ConventionalVehicle, false, false, false, TestName = "ReportResult_WritingResults: Lorry Conv ERROR"), + + TestCase(VectoSimulationJobType.ParallelHybridVehicle, true, false, true, TestName = "ReportResult_WritingResults: Lorry HEV OVC SUCCESS"), TestCase(VectoSimulationJobType.ParallelHybridVehicle, true, false, false, TestName = "ReportResult_WritingResults: Lorry HEV OVC ERROR"), - TestCase(VectoSimulationJobType.ParallelHybridVehicle, true, false, true, TestName = "ReportResult_WritingResults: Lorry HEV OVC"), + TestCase(VectoSimulationJobType.ParallelHybridVehicle, false, false, true, TestName = "ReportResult_WritingResults: Lorry HEV non-OVC SUCCESS"), + TestCase(VectoSimulationJobType.ParallelHybridVehicle, false, false, false, TestName = "ReportResult_WritingResults: Lorry HEV non-OVC ERROR"), + + TestCase(VectoSimulationJobType.BatteryElectricVehicle, true, false, true, TestName = "ReportResult_WritingResults: Lorry PEV SUCCESS"), + TestCase(VectoSimulationJobType.BatteryElectricVehicle, true, false, false, TestName = "ReportResult_WritingResults: Lorry PEV ERROR"), + TestCase(VectoSimulationJobType.ParallelHybridVehicle, true, true, true, TestName = "ReportResult_WritingResults: Lorry HEV exempted"), + TestCase(VectoSimulationJobType.ConventionalVehicle, true, true, true, TestName = "ReportResult_WritingResults: Lorry Conv exempted"), ] public void TestReportResult_WritingResults_Lorry(VectoSimulationJobType jobType, bool ovc, bool exempted, bool success) { @@ -81,7 +91,7 @@ public class TestXMLResultsWriting resultEntry.SetResultData(runData, modData, 1); resultEntries.Add(resultEntry); - if (ovc) { + if (ovc && jobType.GetPowertrainArchitectureType() == VectoSimulationJobTypeHelper.Hybrid) { var run2 = GetMockRunData(vehicleCategory, jobType, true, exempted, VectoRunData.OvcHevMode.ChargeSustaining); var res2 = GetResultEntry(run2); res2.SetResultData(run2, modData, 1); @@ -99,22 +109,28 @@ public class TestXMLResultsWriting var doc = CreateXmlDocument(results); var validator = GetValidator(doc); - var m = new MemoryStream(); - var writer = new XmlTextWriter(m, Encoding.UTF8) {Formatting = Formatting.Indented}; - doc.WriteTo(writer); - writer.Flush(); - m.Flush(); - m.Seek(0, SeekOrigin.Begin); - Console.WriteLine(new StreamReader(m).ReadToEnd()); - + WriteToConsole(doc); + Assert.IsTrue(validator.ValidateXML(XmlDocumentType.CustomerReport), validator.ValidationError); + + WriteToFile(doc, runData, success, exempted); } + [ + TestCase(VectoSimulationJobType.ConventionalVehicle, false, false, true, TestName = "ReportResult_WritingResults: CompletedBus Conv SUCCESS"), + TestCase(VectoSimulationJobType.ConventionalVehicle, false, false, false, TestName = "ReportResult_WritingResults: CompletedBus Conv ERROR"), + + TestCase(VectoSimulationJobType.ParallelHybridVehicle, true, false, true, TestName = "ReportResult_WritingResults: CompletedBus HEV OVC SUCCESS"), TestCase(VectoSimulationJobType.ParallelHybridVehicle, true, false, false, TestName = "ReportResult_WritingResults: CompletedBus HEV OVC ERROR"), - TestCase(VectoSimulationJobType.ParallelHybridVehicle, true, false, true, TestName = "ReportResult_WritingResults: CompletedBus HEV OVC"), + TestCase(VectoSimulationJobType.ParallelHybridVehicle, false, false, true, TestName = "ReportResult_WritingResults: CompletedBus HEV non-OVC SUCCESS"), + TestCase(VectoSimulationJobType.ParallelHybridVehicle, false, false, false, TestName = "ReportResult_WritingResults: CompletedBus HEV non-OVC ERROR"), + + TestCase(VectoSimulationJobType.BatteryElectricVehicle, true, false, true, TestName = "ReportResult_WritingResults: CompletedBus PEV SUCCESS"), + TestCase(VectoSimulationJobType.BatteryElectricVehicle, true, false, false, TestName = "ReportResult_WritingResults: CompletedBus PEV ERROR"), + TestCase(VectoSimulationJobType.ParallelHybridVehicle, true, true, true, TestName = "ReportResult_WritingResults: CompletedBus HEV exempted"), ] public void TestReportResult_WritingResults_CompletedBus(VectoSimulationJobType jobType, bool ovc, bool exempted, bool success) @@ -130,7 +146,7 @@ public class TestXMLResultsWriting resultEntry.SetResultData(runData, modData, 1); resultEntries.Add(resultEntry); - if (ovc) { + if (ovc && jobType.GetPowertrainArchitectureType() == VectoSimulationJobTypeHelper.Hybrid) { var run2 = GetMockRunData(vehicleCategory, jobType, true, exempted, VectoRunData.OvcHevMode.ChargeSustaining); var res2 = GetResultEntry(run2); res2.SetResultData(run2, modData, 1); @@ -148,6 +164,15 @@ public class TestXMLResultsWriting var doc = CreateXmlDocument(results); var validator = GetValidator(doc); + WriteToConsole(doc); + + Assert.IsTrue(validator.ValidateXML(XmlDocumentType.CustomerReport), validator.ValidationError); + + WriteToFile(doc, runData, success, exempted); + } + + private static void WriteToConsole(XDocument doc) + { var m = new MemoryStream(); var writer = new XmlTextWriter(m, Encoding.UTF8) { Formatting = Formatting.Indented }; doc.WriteTo(writer); @@ -155,10 +180,50 @@ public class TestXMLResultsWriting m.Flush(); m.Seek(0, SeekOrigin.Begin); Console.WriteLine(new StreamReader(m).ReadToEnd()); + } - Assert.IsTrue(validator.ValidateXML(XmlDocumentType.CustomerReport), validator.ValidationError); + + private void WriteToFile(XDocument doc, VectoRunData runData, bool success, bool exempted) + { + lock (this) { + var fileName = GetFilename(runData, success, exempted); + var filePath = Path.Combine("TestDummyResults", fileName); + if (!Directory.Exists(Path.GetDirectoryName(filePath))) { + Directory.CreateDirectory(Path.GetDirectoryName(filePath)); + } + + if (File.Exists(filePath)) { + File.Delete(filePath); + } + + var writer = new XmlTextWriter(filePath, Encoding.UTF8) { Formatting = Formatting.Indented }; + doc.WriteTo(writer); + writer.Flush(); + } } + private string GetFilename(VectoRunData runData, bool success, bool exempted) + { + var arch = string.Empty; + switch (runData.JobType.GetPowertrainArchitectureType()) { + case VectoSimulationJobTypeHelper.Hybrid: + arch = (runData.VehicleData.OffVehicleCharging ? "OVC" : "non-OVC") + "-HEV"; + break; + case VectoSimulationJobTypeHelper.Conventional: + arch = "Conv"; + break; + case VectoSimulationJobTypeHelper.PureElectric: + arch = "PEV"; + break; + } + + var category = runData.VehicleData.VehicleCategory.IsLorry() ? "Lorry" : "Bus"; + var suffix = success ? null : "_ERR"; + var exept = exempted ? "_exempted" : null; + return $"CIF_MockupResults_{arch}_{category}{suffix}{exept}.xml"; + } + + private static XMLDeclarationReport.ResultEntry GetResultEntry(VectoRunData runData) { var resultEntry = new XMLDeclarationReport.ResultEntry() {