writing CIF results for lorries works

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>();
 		}
 	}
 }

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; }

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());

VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/CIFResultWriter.cs

+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

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

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)))
 			);
 

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(),

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

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) { }
-	}
 }
 

VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/ResultTotalWriter.cs

+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

VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/ResultWriter.cs

+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

VectoCore/VectoCore/OutputData/XML/DeclarationReports/CustomerInformationFile/CustomerInformationFile_0_9/ResultWriter/SummaryWriter.cs

+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

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

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() {