From e394ae634cb7bbf2c01c6eff529558639ea40089 Mon Sep 17 00:00:00 2001
From: Markus Quaritsch <markus.quaritsch@tugraz.at>
Date: Fri, 2 Sep 2022 14:50:20 +0200
Subject: [PATCH] refactoring mod and sum data column creation. adapting
 testcases.

---
 .../MultistageJobViewModel_v0_1.cs            |   3 +-
 .../InputData/FileIO/JSON/JSONInputData.cs    |   4 +-
 .../Models/Simulation/Data/ModalResult.cs     |  20 ++--
 .../Models/Simulation/IVehicleContainer.cs    |   2 +
 .../Simulation/Impl/PowertrainBuilder.cs      |   8 +-
 .../Simulation/Impl/VehicleContainer.cs       |   9 +-
 .../Impl/BusAuxiliariesAdapter.cs             |   6 +-
 .../SimulationComponent/Impl/ElectricMotor.cs |   2 +-
 .../Impl/EngineAuxiliary.cs                   |   4 +-
 .../OutputData/IModalDataContainer.cs         |  10 +-
 .../OutputData/ModalDataContainer.cs          |   4 +
 .../VectoCore/OutputData/SumDataFields.cs     |  28 ++---
 .../OutputData/SummaryDataContainer.cs        | 106 ++++++++++++------
 .../OutputData/XML/XMLDeclarationReport.cs    |   2 +-
 .../CO2Standards/MissionProfileWeights.csv    |   1 +
 .../VectoCoreTest/Integration/ATPowerTrain.cs |  12 +-
 .../BatteryElectric/BatteryElectricTest.cs    |  10 +-
 .../Integration/CoachPowerTrain.cs            |   2 +-
 .../DriverStrategy/SimpleCycles.cs            |   2 +-
 .../EngineOnlyCycle/EngineOnlyCycleTest.cs    |   1 +
 .../Integration/Hybrid/SerialHybridTest.cs    |  10 +-
 .../Integration/Truck40tPowerTrain.cs         |   2 +-
 .../EngineeringModeBusAuxTest.cs              |   2 +-
 .../Models/Simulation/AuxTests.cs             |   2 +-
 .../Models/Simulation/MockSumWriter.cs        |   1 +
 .../Models/Simulation/PwheelModeTests.cs      |   2 +-
 .../SimulationComponent/ATGearboxTest.cs      |  15 ++-
 .../Models/SimulationComponent/BatteryTest.cs |  40 ++++---
 .../CombustionEngineTest.cs                   |   4 +-
 .../ElectricMotorEfficienyMapTest.cs          |  41 +++++++
 .../Reports/GearshiftCountTest.cs             |  17 ++-
 .../Reports/ModDataPostprocessingTest.cs      |  99 +++++++++++++++-
 .../VectoCoreTest/Reports/ModDataTest.cs      |  67 ++++++-----
 .../VectoCoreTest/Reports/SumWriterTest.cs    |  39 ++++++-
 .../FactorMethod/CompletedBus_41-32b.vecto    |  15 ++-
 .../Multistage/newVifInterimDiesel.vecto      |   8 +-
 .../Conventional_primaryBus_AMT_n_opt.xml     |   2 +-
 .../Utils/MockVehicleContainer.cs             |   8 ++
 .../XML/XMLDeclarationInputv24.cs             |   4 +-
 39 files changed, 432 insertions(+), 182 deletions(-)

diff --git a/VECTO3GUI2020/ViewModel/MultiStage/Implementation/MultistageJobViewModel_v0_1.cs b/VECTO3GUI2020/ViewModel/MultiStage/Implementation/MultistageJobViewModel_v0_1.cs
index dcb14c19bb..6376d90a92 100644
--- a/VECTO3GUI2020/ViewModel/MultiStage/Implementation/MultistageJobViewModel_v0_1.cs
+++ b/VECTO3GUI2020/ViewModel/MultiStage/Implementation/MultistageJobViewModel_v0_1.cs
@@ -207,7 +207,7 @@ namespace VECTO3GUI2020.ViewModel.MultiStage.Implementation
 				//var factory = SimulatorFactory.CreateSimulatorFactory(ExecutionMode.Declaration, inputData, writer);
 					FileHelper.CreateDirectory(outputFile);
 
-					var jobContainer = new JobContainer(new NullSumWriter());
+					var jobContainer = new JobContainer(new NullSumWriter(writer));
 
 					jobContainer.AddRuns(factory);
 					jobContainer.Execute();
@@ -433,5 +433,6 @@ namespace VECTO3GUI2020.ViewModel.MultiStage.Implementation
 		public override void Write(IModalDataContainer modData, VectoRunData runData) { }
 
 		public override void Finish() { }
+		public NullSumWriter(ISummaryWriter writer) : base(writer) { }
 	}
 }
\ No newline at end of file
diff --git a/VectoCore/VectoCore/InputData/FileIO/JSON/JSONInputData.cs b/VectoCore/VectoCore/InputData/FileIO/JSON/JSONInputData.cs
index 83a7e4610f..82109cf474 100644
--- a/VectoCore/VectoCore/InputData/FileIO/JSON/JSONInputData.cs
+++ b/VectoCore/VectoCore/InputData/FileIO/JSON/JSONInputData.cs
@@ -795,9 +795,9 @@ namespace TUGraz.VectoCore.InputData.FileIO.JSON
 			}
 
 			_manufacturerResults = new ManufacturerResults(xmlDoc.SelectSingleNode("//*[local-name() = 'Results']"));
-			_vehicleLenght = xmlDoc.SelectSingleNode("//*[local-name() = 'VehicleLength']").InnerText.ToDouble().SI<Meter>();
+			_vehicleLenght = xmlDoc.SelectSingleNode("//*[local-name() = 'VehicleLength']")?.InnerText.ToDouble().SI<Meter>();
 			_vehicleClass = VehicleClassHelper.Parse(xmlDoc.SelectSingleNode("//*[local-name() = 'VehicleGroup']").InnerText);
-			_vehicleCode = xmlDoc.SelectSingleNode("//*[local-name() = 'VehicleCode']").InnerText.ParseEnum<VehicleCode>();
+			_vehicleCode = xmlDoc.SelectSingleNode("//*[local-name() = 'VehicleCode']")?.InnerText.ParseEnum<VehicleCode>() ?? VehicleCode.NOT_APPLICABLE;
 		}
 	}
 
diff --git a/VectoCore/VectoCore/Models/Simulation/Data/ModalResult.cs b/VectoCore/VectoCore/Models/Simulation/Data/ModalResult.cs
index 45bfe1a772..c9417c85bc 100644
--- a/VectoCore/VectoCore/Models/Simulation/Data/ModalResult.cs
+++ b/VectoCore/VectoCore/Models/Simulation/Data/ModalResult.cs
@@ -326,6 +326,8 @@ namespace TUGraz.VectoCore.Models.Simulation.Data
 		{
 			switch (component) {
 				case ICombustionEngine c1: CreateCombustionEngineColumns(runData); break;
+				case BusAuxiliariesAdapter _: CreateColumns(BusAuxiliariesSignals); break;
+				case PWheelCycle _: CreateColumns(WheelSignals); CreateColumns(DriverSignals); break;
 				case IClutch _:
 					CreateColumns(ClutchSignals);
 					break;
@@ -343,13 +345,13 @@ namespace TUGraz.VectoCore.Models.Simulation.Data
 				case Retarder _: CreateColumns(RetarderSignals); break;
 				case IWheels _: CreateColumns(WheelSignals); break;
 				case IBrakes _: CreateColumns(BrakeSignals); break;
-				case IDriver _: CreateColumns(DriverSignals); break;
+				case IDriverInfo _: CreateColumns(DriverSignals); break;
 				case IVehicle _: CreateColumns(VehicleSignals); break;
 				case IElectricMotor c3 when c3.Position == PowertrainPosition.IEPC: 
-					CreateElectricMotorColumns(c3, runData, IEPCSignals);
+					CreateElectricMotorColumns(c3.Position, runData, IEPCSignals);
 					break;
 				case IElectricMotor c4 when c4.Position != PowertrainPosition.IEPC:
-					CreateElectricMotorColumns(c4, runData, ElectricMotorSignals);
+					CreateElectricMotorColumns(c4.Position, runData, ElectricMotorSignals);
 					break;
 				case IElectricEnergyStorage c5 when c5 is BatterySystem: CreateBatteryColumns(runData);
 					break;
@@ -385,12 +387,12 @@ namespace TUGraz.VectoCore.Models.Simulation.Data
 		}
 	
 
-		private void CreateElectricMotorColumns(IElectricMotor em, VectoRunData runData,
+		protected internal void CreateElectricMotorColumns(PowertrainPosition emPos, VectoRunData runData,
 			ModalResultField[] signals)
 		{
-			ElectricMotors.Add(em.Position);
+			ElectricMotors.Add(emPos);
 			foreach (var entry in signals) {
-				var col = Columns.Add(string.Format(entry.GetAttribute().Caption, em.Position.GetName()), typeof(SI));
+				var col = Columns.Add(string.Format(entry.GetAttribute().Caption, emPos.GetName()), typeof(SI));
 				col.ExtendedProperties[ModalResults.ExtendedPropertyNames.Decimals] =
 					entry.GetAttribute().Decimals;
 				col.ExtendedProperties[ModalResults.ExtendedPropertyNames.OutputFactor] =
@@ -403,9 +405,9 @@ namespace TUGraz.VectoCore.Models.Simulation.Data
 		protected internal void CreateCombustionEngineColumns(VectoRunData runData)
 		{
 			CreateColumns(CombustionEngineSignals);
-			if (runData.BusAuxiliaries != null) {
-				CreateColumns(BusAuxiliariesSignals);
-			}
+			//if (runData.BusAuxiliaries != null) {
+			//	CreateColumns(BusAuxiliariesSignals);
+			//}
 			var multipleEngineModes = runData.EngineData?.MultipleEngineFuelModes ?? false;
 			var fuels = runData.EngineData?.Fuels ?? new List<CombustionEngineFuelData>();
 			foreach (var fuel in fuels) {
diff --git a/VectoCore/VectoCore/Models/Simulation/IVehicleContainer.cs b/VectoCore/VectoCore/Models/Simulation/IVehicleContainer.cs
index 6000d8386c..3d3cf62f75 100644
--- a/VectoCore/VectoCore/Models/Simulation/IVehicleContainer.cs
+++ b/VectoCore/VectoCore/Models/Simulation/IVehicleContainer.cs
@@ -65,6 +65,8 @@ namespace TUGraz.VectoCore.Models.Simulation
 		/// <param name="component"></param>
 		void AddComponent(VectoSimulationComponent component);
 
+		void AddAuxiliary(string id, string columnName = null);
+
 		/// <summary>
 		/// Commits the current simulation step.
 		/// </summary>
diff --git a/VectoCore/VectoCore/Models/Simulation/Impl/PowertrainBuilder.cs b/VectoCore/VectoCore/Models/Simulation/Impl/PowertrainBuilder.cs
index 2639aeed79..9fb373c34f 100644
--- a/VectoCore/VectoCore/Models/Simulation/Impl/PowertrainBuilder.cs
+++ b/VectoCore/VectoCore/Models/Simulation/Impl/PowertrainBuilder.cs
@@ -764,7 +764,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 				}
 				rdSwpAux = new RoadSweeperAuxiliary(container);
 				pto.Add(Constants.Auxiliaries.IDs.PTORoadsweeping, (nEng, absTime, dt, dryRun) => rdSwpAux.PowerDemand(nEng, absTime, dt, dryRun) / nEng);
-				container.ModalData?.AddAuxiliary(Constants.Auxiliaries.IDs.PTORoadsweeping, Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTORoadsweeping);
+				container.AddAuxiliary(Constants.Auxiliaries.IDs.PTORoadsweeping, Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTORoadsweeping);
 			}
 
 			if (data.ExecutionMode == ExecutionMode.Engineering &&
@@ -775,17 +775,17 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 
 				ptoDrive = new PTODriveAuxiliary(container, data.PTOCycleWhileDrive);
 				pto.Add(Constants.Auxiliaries.IDs.PTODuringDrive, (nEng, absTime, dt, dryRun) => ptoDrive.PowerDemand(nEng, absTime, dt, dryRun) / nEng);
-				container.ModalData?.AddAuxiliary(Constants.Auxiliaries.IDs.PTODuringDrive, Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTODuringDrive);
+				container.AddAuxiliary(Constants.Auxiliaries.IDs.PTODuringDrive, Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTODuringDrive);
 			}
 			if (data.PTO != null) {
 				pto.AddConstant(Constants.Auxiliaries.IDs.PTOTransmission,
 								DeclarationData.PTOTransmission.Lookup(data.PTO.TransmissionType).TorqueLoss);
-				container.ModalData?.AddAuxiliary(Constants.Auxiliaries.IDs.PTOTransmission,
+				container.AddAuxiliary(Constants.Auxiliaries.IDs.PTOTransmission,
 												Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTOTransmission);
 
 				pto.Add(Constants.Auxiliaries.IDs.PTOConsumer,
 						(n, absTime, dt, dryRun) => container.DrivingCycleInfo.PTOActive || (rdSwpAux?.Active(absTime) ?? false) || (ptoDrive?.Active(absTime) ?? false) ? null : data.PTO.LossMap.GetTorqueLoss(n));
-				container.ModalData?.AddAuxiliary(Constants.Auxiliaries.IDs.PTOConsumer,
+				container.AddAuxiliary(Constants.Auxiliaries.IDs.PTOConsumer,
 												Constants.Auxiliaries.PowerPrefix + Constants.Auxiliaries.IDs.PTOConsumer);
 			}
 
diff --git a/VectoCore/VectoCore/Models/Simulation/Impl/VehicleContainer.cs b/VectoCore/VectoCore/Models/Simulation/Impl/VehicleContainer.cs
index 4fe1178e02..00c21c0ac9 100644
--- a/VectoCore/VectoCore/Models/Simulation/Impl/VehicleContainer.cs
+++ b/VectoCore/VectoCore/Models/Simulation/Impl/VehicleContainer.cs
@@ -93,7 +93,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 
 		internal IModalDataContainer ModData;
 
-		internal ISumData WriteSumData;
+		protected ISumData WriteSumData;
 
 		internal readonly IList<ISimulationPreprocessor> Preprocessors = new List<ISimulationPreprocessor>();
 
@@ -202,6 +202,13 @@ namespace TUGraz.VectoCore.Models.Simulation.Impl
 
 			WriteSumData?.RegisterComponent(component, RunData);
 		}
+
+		public void AddAuxiliary(string id, string columnName = null)
+		{
+			ModalData?.AddAuxiliary(id, columnName);
+			WriteSumData?.AddAuxiliary(id);
+		}
+
 		private List<(IUpdateable, object)> ComponentUpdateList = new List<(IUpdateable, object)>();
 
 		protected void UpdateComponentsInternal(IDataBus realContainer)
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Impl/BusAuxiliariesAdapter.cs b/VectoCore/VectoCore/Models/SimulationComponent/Impl/BusAuxiliariesAdapter.cs
index a2f3f19d39..5ffb663132 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Impl/BusAuxiliariesAdapter.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Impl/BusAuxiliariesAdapter.cs
@@ -61,7 +61,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 		public BusAuxiliariesAdapter(
 			IVehicleContainer container, IAuxiliaryConfig auxiliaryConfig, IAuxPort additionalAux = null) : base(container)
 		{
-			container.AddComponent(this);
+			//container.AddComponent(this);
 
 			CurrentState = new BusAuxState();
 			PreviousState = new BusAuxState { AngularSpeed = container.EngineInfo.EngineIdleSpeed };
@@ -254,7 +254,9 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			//var newSOC = Auxiliaries.BatterySOC;
 
 			//CurrentState.TotalFuelConsumption = Auxiliaries.TotalFuel;
-			container[ModalResultField.P_aux_mech] = CurrentState.PowerDemand;
+			if (container.HasCombustionEngine) {
+				container[ModalResultField.P_aux_mech] = CurrentState.PowerDemand;
+			}
 
 			container[ModalResultField.P_busAux_ES_HVAC] = /*essUtilityFactor **/ Auxiliaries.HVACElectricalPowerConsumer;
 			container[ModalResultField.P_busAux_ES_other] = /*essUtilityFactor **/ Auxiliaries.ElectricPowerConsumer;
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Impl/ElectricMotor.cs b/VectoCore/VectoCore/Models/SimulationComponent/Impl/ElectricMotor.cs
index 88247fe0a3..1a62deb6df 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Impl/ElectricMotor.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Impl/ElectricMotor.cs
@@ -44,7 +44,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 				}
 			}
 
-			container.AddComponent(this); // We have to do this again because in the base class the position is unknown!
+			container?.AddComponent(this); // We have to do this again because in the base class the position is unknown!
 
 			if (ModelData.Overload.OverloadBuffer.IsSmallerOrEqual(0) && !(container is SimplePowertrainContainer)) {
 				Log.Error("Overload buffer for thermal de-rating is zero or negative! Please check electric motor data!");
diff --git a/VectoCore/VectoCore/Models/SimulationComponent/Impl/EngineAuxiliary.cs b/VectoCore/VectoCore/Models/SimulationComponent/Impl/EngineAuxiliary.cs
index 3d071bae43..2cc4505bd9 100644
--- a/VectoCore/VectoCore/Models/SimulationComponent/Impl/EngineAuxiliary.cs
+++ b/VectoCore/VectoCore/Models/SimulationComponent/Impl/EngineAuxiliary.cs
@@ -100,8 +100,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 		public void Add(string auxId, Func<PerSecond, Second, Second, bool, Watt> powerLossFunction, string columnName = null)
 		{
 			Auxiliaries[auxId] = powerLossFunction;
-			(DataBus as IVehicleContainer)?.ModalData?.AddAuxiliary(auxId, columnName);
-			(DataBus as IVehicleContainer)?.SumData?.AddAuxiliary(auxId);
+			(DataBus as IVehicleContainer)?.AddAuxiliary(auxId, columnName);
+			//(DataBus as IVehicleContainer)?.SumData?.AddAuxiliary(auxId);
 		}
 
 		public NewtonMeter Initialize(NewtonMeter torque, PerSecond angularSpeed)
diff --git a/VectoCore/VectoCore/OutputData/IModalDataContainer.cs b/VectoCore/VectoCore/OutputData/IModalDataContainer.cs
index 6bba3a4a57..b05edf3523 100644
--- a/VectoCore/VectoCore/OutputData/IModalDataContainer.cs
+++ b/VectoCore/VectoCore/OutputData/IModalDataContainer.cs
@@ -101,12 +101,12 @@ namespace TUGraz.VectoCore.OutputData
 
 		void SetDataValue(string fieldName, object value);
 
-		void AddAuxiliary(string id, string columnName = null);
+        void AddAuxiliary(string id, string columnName = null);
 
-		/// <summary>
-		/// Finishes the writing of the DataWriter.
-		/// </summary>
-		void Finish(VectoRun.Status runStatus, Exception exception = null);
+        /// <summary>
+        /// Finishes the writing of the DataWriter.
+        /// </summary>
+        void Finish(VectoRun.Status runStatus, Exception exception = null);
 
 		/// <summary>
 		/// clear the modal data after the simulation
diff --git a/VectoCore/VectoCore/OutputData/ModalDataContainer.cs b/VectoCore/VectoCore/OutputData/ModalDataContainer.cs
index ed9bad665f..a13d428e36 100644
--- a/VectoCore/VectoCore/OutputData/ModalDataContainer.cs
+++ b/VectoCore/VectoCore/OutputData/ModalDataContainer.cs
@@ -191,6 +191,10 @@ namespace TUGraz.VectoCore.OutputData
 			if (_runData.Cycle.CycleType == CycleType.EngineOnly) {
 				return null;
 			}
+
+			if (!Data.Columns.Contains(ModalResultField.P_wheel_in.GetName())) {
+				return null;
+			}
 			if (_vehLine.TryGetValue(fuel.FuelType, out var value)) {
 				return value;
 			}
diff --git a/VectoCore/VectoCore/OutputData/SumDataFields.cs b/VectoCore/VectoCore/OutputData/SumDataFields.cs
index 63467ac2e1..2dc5127905 100644
--- a/VectoCore/VectoCore/OutputData/SumDataFields.cs
+++ b/VectoCore/VectoCore/OutputData/SumDataFields.cs
@@ -343,8 +343,8 @@ namespace TUGraz.VectoCore.OutputData
 			{ VIN_NUMBER, SumFunc((r, m) => r.VehicleData?.VIN ?? Constants.NOT_AVAILABLE)},
 			{ VEHICLE_MODEL, SumFunc((r, m) => r.VehicleData?.ModelName ?? Constants.NOT_AVAILABLE)},
 			{ HDV_CO2_VEHICLE_CLASS, SumFunc((r, m) => r.Mission?.BusParameter?.BusGroup.GetClassNumber() ?? r.VehicleData?.VehicleClass.GetClassNumber() ?? VehicleClass.Unknown.GetClassNumber())},
-			{ CURB_MASS, SumFunc((r, m) => (ConvertedSI)r.VehicleData.CurbMass)},
-			{ LOADING, SumFunc((r, m) => (ConvertedSI)r.VehicleData.Loading)},
+			{ CURB_MASS, SumFunc((r, m) => (ConvertedSI)r.VehicleData?.CurbMass)},
+			{ LOADING, SumFunc((r, m) => (ConvertedSI)r.VehicleData?.Loading)},
 			{ PassengerCount, SumFunc((r, m) => r.VehicleData.PassengerCount)},
 			{ CARGO_VOLUME, SumFunc((r, m) => (ConvertedSI)r.VehicleData?.CargoVolume)},
 			{ TOTAL_VEHICLE_MASS, SumFunc((r, m) => (ConvertedSI)r.VehicleData?.TotalVehicleMass)},
@@ -401,20 +401,20 @@ namespace TUGraz.VectoCore.OutputData
 			{ NUM_AXLES_NON_DRIVEN, SumFunc((r, m) => r.VehicleData?.AxleData.Count(x => x.AxleType == AxleType.VehicleNonDriven))},
 			{ NUM_AXLES_TRAILER, SumFunc((r, m) => r.VehicleData?.AxleData.Count(x => x.AxleType == AxleType.Trailer))},
 
-			{ DECLARED_RRC_AXLE1, SumFunc((r, m) => r.VehicleData?.AxleData.Count > 0 && r.VehicleData.AxleData[0].AxleType != AxleType.Trailer ? r.VehicleData.AxleData[0].RollResistanceCoefficient : double.NaN) },
-			{ DECLARED_RRC_AXLE2, SumFunc((r, m) => r.VehicleData?.AxleData.Count > 1 && r.VehicleData.AxleData[1].AxleType != AxleType.Trailer ? r.VehicleData.AxleData[1].RollResistanceCoefficient : double.NaN) },
-			{ DECLARED_RRC_AXLE3, SumFunc((r, m) => r.VehicleData?.AxleData.Count > 2 && r.VehicleData.AxleData[2].AxleType != AxleType.Trailer ? r.VehicleData.AxleData[2].RollResistanceCoefficient : double.NaN) },
-			{ DECLARED_RRC_AXLE4, SumFunc((r, m) => r.VehicleData?.AxleData.Count > 3 && r.VehicleData.AxleData[3].AxleType != AxleType.Trailer ? r.VehicleData.AxleData[3].RollResistanceCoefficient : double.NaN) },
+			{ DECLARED_RRC_AXLE1, SumFunc((r, m) => r.VehicleData?.AxleData?.Count > 0 && r.VehicleData.AxleData[0].AxleType != AxleType.Trailer ? r.VehicleData.AxleData[0].RollResistanceCoefficient : double.NaN) },
+			{ DECLARED_RRC_AXLE2, SumFunc((r, m) => r.VehicleData?.AxleData?.Count > 1 && r.VehicleData.AxleData[1].AxleType != AxleType.Trailer ? r.VehicleData.AxleData[1].RollResistanceCoefficient : double.NaN) },
+			{ DECLARED_RRC_AXLE3, SumFunc((r, m) => r.VehicleData?.AxleData?.Count > 2 && r.VehicleData.AxleData[2].AxleType != AxleType.Trailer ? r.VehicleData.AxleData[2].RollResistanceCoefficient : double.NaN) },
+			{ DECLARED_RRC_AXLE4, SumFunc((r, m) => r.VehicleData?.AxleData?.Count > 3 && r.VehicleData.AxleData[3].AxleType != AxleType.Trailer ? r.VehicleData.AxleData[3].RollResistanceCoefficient : double.NaN) },
 
-			{ DECLARED_FZISO_AXLE1, SumFunc((r, m) => r.VehicleData?.AxleData.Count > 0 && r.VehicleData.AxleData[0].AxleType != AxleType.Trailer ? (ConvertedSI)r.VehicleData.AxleData[0].TyreTestLoad : null) },
-			{ DECLARED_FZISO_AXLE2, SumFunc((r, m) => r.VehicleData?.AxleData.Count > 1 && r.VehicleData.AxleData[1].AxleType != AxleType.Trailer ? (ConvertedSI)r.VehicleData.AxleData[1].TyreTestLoad : null) },
-			{ DECLARED_FZISO_AXLE3, SumFunc((r, m) => r.VehicleData?.AxleData.Count > 2 && r.VehicleData.AxleData[2].AxleType != AxleType.Trailer ? (ConvertedSI)r.VehicleData.AxleData[2].TyreTestLoad : null) },
-			{ DECLARED_FZISO_AXLE4, SumFunc((r, m) => r.VehicleData?.AxleData.Count > 3 && r.VehicleData.AxleData[3].AxleType != AxleType.Trailer ? (ConvertedSI)r.VehicleData.AxleData[3].TyreTestLoad : null) },
+			{ DECLARED_FZISO_AXLE1, SumFunc((r, m) => r.VehicleData?.AxleData?.Count > 0 && r.VehicleData.AxleData[0].AxleType != AxleType.Trailer ? (ConvertedSI)r.VehicleData.AxleData[0].TyreTestLoad : null) },
+			{ DECLARED_FZISO_AXLE2, SumFunc((r, m) => r.VehicleData?.AxleData?.Count > 1 && r.VehicleData.AxleData[1].AxleType != AxleType.Trailer ? (ConvertedSI)r.VehicleData.AxleData[1].TyreTestLoad : null) },
+			{ DECLARED_FZISO_AXLE3, SumFunc((r, m) => r.VehicleData?.AxleData?.Count > 2 && r.VehicleData.AxleData[2].AxleType != AxleType.Trailer ? (ConvertedSI)r.VehicleData.AxleData[2].TyreTestLoad : null) },
+			{ DECLARED_FZISO_AXLE4, SumFunc((r, m) => r.VehicleData?.AxleData?.Count > 3 && r.VehicleData.AxleData[3].AxleType != AxleType.Trailer ? (ConvertedSI)r.VehicleData.AxleData[3].TyreTestLoad : null) },
 
 			// angle drive
 			{ ANGLEDRIVE_MANUFACTURER, SumFunc((r, m) => r.AngledriveData?.Manufacturer ?? Constants.NOT_AVAILABLE)},
 			{ ANGLEDRIVE_MODEL, SumFunc((r, m) => r.AngledriveData?.ModelName?? Constants.NOT_AVAILABLE)},
-			{ ANGLEDRIVE_RATIO, SumFunc((r, m) => r.AngledriveData?.Angledrive.Ratio)},
+			{ ANGLEDRIVE_RATIO, SumFunc((r, m) =>  (ConvertedSI)r.AngledriveData?.Angledrive.Ratio.SI<Scalar>())},
 			{ ANGLEDRIVE_CERTIFICATION_METHOD, SumFunc((r, m) => r.AngledriveData?.CertificationMethod.GetName() ?? "")},
 			{ ANGLEDRIVE_CERTIFICATION_NUMBER, SumFunc((r, m) => r.AngledriveData == null || r.AngledriveData.CertificationMethod == CertificationMethod.StandardValues ? "" : r.AngledriveData.CertificationNumber)},
 
@@ -592,9 +592,9 @@ namespace TUGraz.VectoCore.OutputData
 
 			// CO2
 			{ CO2_KM, SumFunc((r, m) => m.CorrectedModalData.KilogramCO2PerMeter.ConvertToGrammPerKiloMeter()) },
-			{ CO2_TKM, SumFunc((r, m) => r.VehicleData.Loading == null || r.VehicleData.Loading.IsEqual(0) ? null : (m.CorrectedModalData.KilogramCO2PerMeter / r.VehicleData.Loading).ConvertToGrammPerTonKilometer()) },
-			{ CO2_M3KM, SumFunc((r, m) => r.VehicleData.CargoVolume == null || r.VehicleData.CargoVolume.IsEqual(0) ? null : (m.CorrectedModalData.KilogramCO2PerMeter / r.VehicleData.CargoVolume).ConvertToGrammPerCubicMeterKiloMeter()) },
-			{ CO2_PKM, SumFunc((r, m) => r.VehicleData.PassengerCount == null ? null : (m.CorrectedModalData.KilogramCO2PerMeter / r.VehicleData.PassengerCount.Value).ConvertToGrammPerKiloMeter()) },
+			{ CO2_TKM, SumFunc((r, m) => r.VehicleData?.Loading == null || r.VehicleData.Loading.IsEqual(0) ? null : (m.CorrectedModalData.KilogramCO2PerMeter / r.VehicleData.Loading).ConvertToGrammPerTonKilometer()) },
+			{ CO2_M3KM, SumFunc((r, m) => r.VehicleData?.CargoVolume == null || r.VehicleData.CargoVolume.IsEqual(0) ? null : (m.CorrectedModalData.KilogramCO2PerMeter / r.VehicleData.CargoVolume).ConvertToGrammPerCubicMeterKiloMeter()) },
+			{ CO2_PKM, SumFunc((r, m) => r.VehicleData?.PassengerCount == null ? null : (m.CorrectedModalData.KilogramCO2PerMeter / r.VehicleData.PassengerCount.Value).ConvertToGrammPerKiloMeter()) },
 
 			// electric consumption
 			{ ElectricEnergyConsumptionPerKm, SumFunc(new[] {ModalResultField.P_reess_int}, (r, m) => (-m.TimeIntegral<WattSecond>(ModalResultField.P_reess_int) / m.Distance).Cast<JoulePerMeter>().ConvertToKiloWattHourPerKiloMeter())},
diff --git a/VectoCore/VectoCore/OutputData/SummaryDataContainer.cs b/VectoCore/VectoCore/OutputData/SummaryDataContainer.cs
index 88d17c9b26..69d2b0f5e1 100644
--- a/VectoCore/VectoCore/OutputData/SummaryDataContainer.cs
+++ b/VectoCore/VectoCore/OutputData/SummaryDataContainer.cs
@@ -65,7 +65,7 @@ namespace TUGraz.VectoCore.OutputData
 	/// </summary>
 	public class SummaryDataContainer : LoggingObject, ISumData, IDisposable
 	{
-		protected readonly string[] FcColumns = {
+		public static readonly string[] FcColumns = {
 			SumDataFields.FCMAP_H, SumDataFields.FCMAP_KM,
 			SumDataFields.FCNCVC_H, SumDataFields.FCNCVC_KM,
 			SumDataFields.FCWHTCC_H, SumDataFields.FCWHTCC_KM,
@@ -83,12 +83,21 @@ namespace TUGraz.VectoCore.OutputData
 			SumDataFields.SPECIFIC_FC, SumDataFields.K_VEHLINE, SumDataFields.K_ENGLINE
 		};
 
-		public static Tuple<string, Type>[] CommonColumns = {
+		public static readonly Tuple<string, Type>[] CommonColumns = {
 			Tuple.Create(SumDataFields.SORT, typeof(int)),
 			Tuple.Create(SumDataFields.JOB, typeof(string)),
 			Tuple.Create(SumDataFields.INPUTFILE, typeof(string)),
 			Tuple.Create(SumDataFields.CYCLE, typeof(string)),
 			Tuple.Create(SumDataFields.STATUS, typeof(string)),
+			Tuple.Create(SumDataFields.CURB_MASS, typeof(ConvertedSI)),
+			Tuple.Create(SumDataFields.LOADING, typeof(ConvertedSI)),
+			Tuple.Create(SumDataFields.TIME, typeof(ConvertedSI)),
+			Tuple.Create(SumDataFields.DISTANCE, typeof(ConvertedSI)),
+			Tuple.Create(SumDataFields.SPEED, typeof(ConvertedSI)),
+			Tuple.Create(SumDataFields.ALTITUDE_DELTA, typeof(ConvertedSI)),
+			Tuple.Create(SumDataFields.ACC, typeof(ConvertedSI)),
+			Tuple.Create(SumDataFields.ACC_POS, typeof(ConvertedSI)),
+			Tuple.Create(SumDataFields.ACC_NEG, typeof(ConvertedSI)),
 			// Engine Infos
 			Tuple.Create(SumDataFields.ENGINE_MANUFACTURER, typeof(string)),
 			Tuple.Create(SumDataFields.ENGINE_MODEL, typeof(string)),
@@ -168,9 +177,14 @@ namespace TUGraz.VectoCore.OutputData
 			Tuple.Create(SumDataFields.CARGO_VOLUME, typeof(ConvertedSI)),
 			Tuple.Create(SumDataFields.COASTING_TIME_SHARE, typeof(ConvertedSI)),
 			Tuple.Create(SumDataFields.BRAKING_TIME_SHARE, typeof(ConvertedSI)),
+			Tuple.Create(SumDataFields.ACC_TIMESHARE, typeof(ConvertedSI)),
+			Tuple.Create(SumDataFields.DEC_TIMESHARE, typeof(ConvertedSI)),
+			Tuple.Create(SumDataFields.CRUISE_TIMESHARE, typeof(ConvertedSI)),
+			Tuple.Create(SumDataFields.STOP_TIMESHARE, typeof(ConvertedSI)),
+
 		};
 
-		public static Tuple<string, Type>[] CombustionEngineColumns = {
+		public static readonly Tuple<string, Type>[] CombustionEngineColumns = {
 			Tuple.Create(SumDataFields.ICE_FULL_LOAD_TIME_SHARE, typeof(ConvertedSI)),
 			Tuple.Create(SumDataFields.ICE_OFF_TIME_SHARE, typeof(ConvertedSI)),
 			Tuple.Create(SumDataFields.NUM_ICE_STARTS, typeof(ConvertedSI)),
@@ -180,7 +194,7 @@ namespace TUGraz.VectoCore.OutputData
 			Tuple.Create(SumDataFields.E_FCMAP_NEG, typeof(ConvertedSI)),
 		};
 
-		public static Tuple<string, Type>[] VehilceColumns = {
+		public static readonly Tuple<string, Type>[] VehilceColumns = {
 			Tuple.Create(SumDataFields.E_VEHICLE_INERTIA, typeof(ConvertedSI)),
 			Tuple.Create(SumDataFields.E_AIR, typeof(ConvertedSI)),
 			Tuple.Create(SumDataFields.E_ROLL, typeof(ConvertedSI)),
@@ -188,43 +202,43 @@ namespace TUGraz.VectoCore.OutputData
 			Tuple.Create(SumDataFields.E_POWERTRAIN_INERTIA, typeof(ConvertedSI)),
 		};
 
-		public static Tuple<string, Type>[] ClutchColumns = {
+		public static readonly Tuple<string, Type>[] ClutchColumns = {
 			Tuple.Create(SumDataFields.E_CLUTCH_LOSS, typeof(ConvertedSI)),
 		};
 
-		public static Tuple<string, Type>[] GearboxColumns = {
+		public static readonly Tuple<string, Type>[] GearboxColumns = {
 			Tuple.Create(SumDataFields.NUM_GEARSHIFTS, typeof(ConvertedSI)),
-			
+			Tuple.Create(SumDataFields.E_GBX_LOSS, typeof(ConvertedSI))
 		};
 
-		public static Tuple<string, Type>[] IEPCTransmissionColumns = { };
+		public static readonly Tuple<string, Type>[] IEPCTransmissionColumns = { };
 
-		public static Tuple<string, Type>[] TorqueConverterColumns = {
+		public static readonly Tuple<string, Type>[] TorqueConverterColumns = {
 			Tuple.Create(SumDataFields.E_TC_LOSS, typeof(ConvertedSI)),
 		};
 
-		public static Tuple<string, Type>[] AngledriveColumns = {
+		public static readonly Tuple<string, Type>[] AngledriveColumns = {
 			Tuple.Create(SumDataFields.E_ANGLE_LOSS, typeof(ConvertedSI)),
 		};
 
-		public static Tuple<string, Type>[] AxlegearColumns = {
+		public static readonly Tuple<string, Type>[] AxlegearColumns = {
 			Tuple.Create(SumDataFields.E_AXL_LOSS, typeof(ConvertedSI)),
 		};
 
-		public static Tuple<string, Type>[] RetarderColumns = {
+		public static readonly Tuple<string, Type>[] RetarderColumns = {
 			Tuple.Create(SumDataFields.E_RET_LOSS, typeof(ConvertedSI)),
 		};
 
-		public static Tuple<string, Type>[] WheelColumns = {
+		public static readonly Tuple<string, Type>[] WheelColumns = {
 			Tuple.Create(SumDataFields.P_WHEEL, typeof(ConvertedSI)),
 			Tuple.Create(SumDataFields.P_WHEEL_POS, typeof(ConvertedSI)),
 		};
 
-		public static Tuple<string, Type>[] BrakeColumns = {
+		public static readonly Tuple<string, Type>[] BrakeColumns = {
 			Tuple.Create(SumDataFields.E_BRAKE, typeof(ConvertedSI)),
 		};
 
-		public static Tuple<string, Type>[] BatteryColumns = {
+		public static readonly Tuple<string, Type>[] BatteryColumns = {
 			Tuple.Create(SumDataFields.REESS_StartSoC, typeof(double)),
 			Tuple.Create(SumDataFields.REESS_EndSoC, typeof(double)),
 			Tuple.Create(SumDataFields.REESS_DeltaEnergy, typeof(ConvertedSI)),
@@ -235,7 +249,7 @@ namespace TUGraz.VectoCore.OutputData
 			Tuple.Create(SumDataFields.E_REESS_int_dischg, typeof(ConvertedSI)),
 		};
 
-		public static Tuple<string, Type>[] ElectricMotorColumns = {
+		public static readonly Tuple<string, Type>[] ElectricMotorColumns = {
 			Tuple.Create(SumDataFields.EM_AVG_SPEED_FORMAT, typeof(ConvertedSI)),
 			Tuple.Create(SumDataFields.E_EM_Mot_DRIVE_FORMAT, typeof(ConvertedSI)),
 			Tuple.Create(SumDataFields.E_EM_Mot_GENERATE_FORMAT, typeof(ConvertedSI)),
@@ -252,7 +266,7 @@ namespace TUGraz.VectoCore.OutputData
 			Tuple.Create(SumDataFields.E_EM_OFF_TIME_SHARE, typeof(ConvertedSI)),
 		};
 
-		public static Tuple<string, Type>[] IEPCColumns = {
+		public static readonly Tuple<string, Type>[] IEPCColumns = {
 			Tuple.Create(SumDataFields.IEPC_AVG_SPEED_FORMAT, typeof(ConvertedSI)),
 			Tuple.Create(SumDataFields.E_IEPC_DRIVE_FORMAT, typeof(ConvertedSI)),
 			Tuple.Create(SumDataFields.E_IEPC_GENERATE_FORMAT, typeof(ConvertedSI)),
@@ -263,11 +277,21 @@ namespace TUGraz.VectoCore.OutputData
 			Tuple.Create(SumDataFields.E_IEPC_OFF_TIME_SHARE, typeof(ConvertedSI)),
 		};
 
+		public static readonly Tuple<string, Type>[] CO2Columns = {
+			Tuple.Create(SumDataFields.CO2_KM, typeof(ConvertedSI)),
+			Tuple.Create(SumDataFields.CO2_TKM, typeof(ConvertedSI)),
+			Tuple.Create(SumDataFields.CO2_M3KM, typeof(ConvertedSI)),
+			Tuple.Create(SumDataFields.CO2_PKM, typeof(ConvertedSI)),
+		};
+
+		public static readonly Tuple<string, Type>[] VTPCycleColumns = {
+			Tuple.Create(SumDataFields.E_WHEEL, typeof(ConvertedSI)),
+		};
+
 		private object _tableLock = new object();
 		internal readonly DataTable Table;
 		private readonly ISummaryWriter _sumWriter;
-
-		protected SummaryDataContainer() { }
+		private List<string> fcCols = new List<string>();
 
 		/// <summary>
 		/// Initializes a new instance of the <see cref="SummaryDataContainer"/> class.
@@ -279,6 +303,7 @@ namespace TUGraz.VectoCore.OutputData
 			Table = new DataTable();
 			//InitTableColumns();
 			CreateColumns(CommonColumns);
+			CreateColumns(CO2Columns);
 		}
 
 		public void RegisterComponent(VectoSimulationComponent component, VectoRunData runData)
@@ -286,6 +311,7 @@ namespace TUGraz.VectoCore.OutputData
 			switch (component) {
 				case ICombustionEngine _:
 					CreateColumns(CombustionEngineColumns);
+					UpdateTableColumns(runData.EngineData);
 					break;
 				case EngineAuxiliary _:
 					break;
@@ -299,6 +325,10 @@ namespace TUGraz.VectoCore.OutputData
 				case IGearbox _ when runData.JobType == VectoSimulationJobType.IEPC_E:
 				case IGearbox _ when runData.JobType == VectoSimulationJobType.IEPC_S:
 					CreateColumns(IEPCTransmissionColumns);
+					CreateGearTimeShareColumns(runData.GearboxData.GearList);
+					break;
+				case VTPCycle _:
+					CreateColumns(VTPCycleColumns);
 					break;
 				case ITorqueConverter _:
 					CreateColumns(TorqueConverterColumns);
@@ -380,7 +410,7 @@ namespace TUGraz.VectoCore.OutputData
 			}
 		}
 
-		private void CreateColumns(Tuple<string, Type>[] cols)
+		protected internal void CreateColumns(Tuple<string, Type>[] cols)
 		{
 			lock (Table) {
 				Table.Columns.AddRange(cols.Where(x => !Table.Columns.Contains(x.Item1))
@@ -460,19 +490,23 @@ namespace TUGraz.VectoCore.OutputData
 				Constants.Auxiliaries.IDs.SteeringPump, Constants.Auxiliaries.IDs.Fan,
 				Constants.Auxiliaries.IDs.HeatingVentilationAirCondition,
 				Constants.Auxiliaries.IDs.PneumaticSystem, Constants.Auxiliaries.IDs.ElectricSystem
-			}.Select(x => string.Format(SumDataFields.AUX_TECH_FORMAT, x)));
+			}.Select(x => string.Format(SumDataFields.E_AUX_FORMAT, x)));
 
 			cols.AddRange(new[] {
-				SumDataFields.TCU_MODEL, 
-				SumDataFields.ADAS_TECHNOLOGY_COMBINATION, 
-				SumDataFields.PTO_TECHNOLOGY, 
+				SumDataFields.TCU_MODEL,
+				SumDataFields.ADAS_TECHNOLOGY_COMBINATION,
+				SumDataFields.PTO_TECHNOLOGY,
 				SumDataFields.REESS_CAPACITY,
 				SumDataFields.CARGO_VOLUME,
-				SumDataFields.TIME, 
-				SumDataFields.DISTANCE, 
+				SumDataFields.TIME,
+				SumDataFields.DISTANCE,
 				SumDataFields.SPEED,
 				SumDataFields.ALTITUDE_DELTA,
+			});
 
+			cols.AddRange(fcCols);
+
+            cols.AddRange(new[] {
 				SumDataFields.CO2_KM, 
 				SumDataFields.CO2_TKM, 
 				SumDataFields.CO2_M3KM, 
@@ -706,20 +740,20 @@ namespace TUGraz.VectoCore.OutputData
 			}
 		}
 
-		private void UpdateTableColumns(ICollection<IFuelProperties> modDataFuelData,
-			bool engineDataMultipleEngineFuelModes)
+		protected internal void UpdateTableColumns(CombustionEngineData engineData)
 		{
-			foreach (var entry in modDataFuelData) {
+			foreach (var entry in engineData.Fuels) {
 				foreach (var column in FcColumns.Reverse()) {
 					var colName = string.Format(column,
-						modDataFuelData.Count <= 1 && !engineDataMultipleEngineFuelModes
+						engineData.Fuels.Count <= 1 && !engineData.MultipleEngineFuelModes
 							? ""
-							: "_" + entry.FuelType.GetLabel());
+							: "_" + entry.FuelData.FuelType.GetLabel());
 					lock (Table) {
 						if (!Table.Columns.Contains(colName)) {
 							var col = new DataColumn(colName, typeof(ConvertedSI));
 							Table.Columns.Add(col);
 							col.SetOrdinal(Table.Columns.IndexOf(SumDataFields.ALTITUDE_DELTA) + 1);
+							fcCols.Add(colName);
 						}
 					}
 				}
@@ -747,11 +781,11 @@ namespace TUGraz.VectoCore.OutputData
 
 		protected Dictionary<string, object> GetResultDictionary(IModalDataContainer modData, VectoRunData runData)
 		{
-			if (modData.HasCombustionEngine) {
-				lock (_tableLock) {
-					UpdateTableColumns(modData.FuelData, runData.EngineData.MultipleEngineFuelModes);
-				}
-			}
+			//if (modData.HasCombustionEngine) {
+			//	lock (_tableLock) {
+			//		UpdateTableColumns(modData.FuelData, runData.EngineData.MultipleEngineFuelModes);
+			//	}
+			//}
 
 			return new Dictionary<string, object>();
 		}
diff --git a/VectoCore/VectoCore/OutputData/XML/XMLDeclarationReport.cs b/VectoCore/VectoCore/OutputData/XML/XMLDeclarationReport.cs
index 94eb0b2430..7046746bc1 100644
--- a/VectoCore/VectoCore/OutputData/XML/XMLDeclarationReport.cs
+++ b/VectoCore/VectoCore/OutputData/XML/XMLDeclarationReport.cs
@@ -169,7 +169,7 @@ namespace TUGraz.VectoCore.OutputData.XML
 
 				var eAxlIn = data.TimeIntegral<WattSecond>(ModalResultField.P_axle_in, x => x > 0);
 				var eAxlOut = data.TimeIntegral<WattSecond>(ModalResultField.P_brake_in, x => x > 0);
-				AverageAxlegearEfficiency = eAxlOut / eAxlIn;
+				AverageAxlegearEfficiency = eAxlOut == null || eAxlIn == null ? double.NaN : eAxlOut / eAxlIn;
 
 				WeightingFactor = weightingFactor;
 
diff --git a/VectoCore/VectoCore/Resources/Declaration/CO2Standards/MissionProfileWeights.csv b/VectoCore/VectoCore/Resources/Declaration/CO2Standards/MissionProfileWeights.csv
index 24a69688c2..645dc53038 100644
--- a/VectoCore/VectoCore/Resources/Declaration/CO2Standards/MissionProfileWeights.csv
+++ b/VectoCore/VectoCore/Resources/Declaration/CO2Standards/MissionProfileWeights.csv
@@ -1,4 +1,5 @@
 Weighting Group , LongHaul  , LongHaul EMS , Regional Delivery , Regional Delivery EMS , Urban Delivery , Municipal Utility , Construction
+
 1s              , 0/0       , 0/0          , 0.1/0.4           , 0/0                   , 0.15/0.35      , 0/0               , 0/0
 1               , 0/0       , 0/0          , 0.1/0.3           , 0/0                   , 0.18/0.42      , 0/0               , 0/0
 2               , 0/0       , 0/0          , 0.125/0.375       , 0/0                   , 0.15/0.35      , 0/0               , 0/0
diff --git a/VectoCore/VectoCoreTest/Integration/ATPowerTrain.cs b/VectoCore/VectoCoreTest/Integration/ATPowerTrain.cs
index ce8b41271b..009f5f9ad8 100644
--- a/VectoCore/VectoCoreTest/Integration/ATPowerTrain.cs
+++ b/VectoCore/VectoCoreTest/Integration/ATPowerTrain.cs
@@ -65,15 +65,17 @@ namespace TUGraz.VectoCore.Tests.Integration
 		public const string TorqueConverterPowerSplitFile = @"TestData\Components\AT_GBX\TorqueConverterPowerSplit.vtcc";
 		public const string GearboxShiftPolygonFile = @"TestData\Components\AT_GBX\AT-Shift.vgbs";
 
-		public static VectoRun CreateEngineeringRun(DrivingCycleData cycleData, GearboxType gbxType, string modFileName,
+		public static VectoRun CreateEngineeringRun(DrivingCycleData cycleData, GearboxType gbxType,
+			SummaryDataContainer summaryDataContainer, string modFileName,
 			bool overspeed = false, KilogramSquareMeter gearBoxInertia = null)
 		{
-			var container = CreatePowerTrain(cycleData, gbxType, Path.GetFileNameWithoutExtension(modFileName), overspeed,
+			var container = CreatePowerTrain(cycleData, gbxType, summaryDataContainer, Path.GetFileNameWithoutExtension(modFileName), overspeed,
 				gearBoxInertia);
 			return new DistanceRun(container);
 		}
 
-		public static VehicleContainer CreatePowerTrain(DrivingCycleData cycleData, GearboxType gbxType, string modFileName,
+		public static VehicleContainer CreatePowerTrain(DrivingCycleData cycleData, GearboxType gbxType,
+			SummaryDataContainer summaryDataContainer, string modFileName,
 			bool overspeed = false, KilogramSquareMeter gearBoxInertia = null)
 		{
 			var gearboxData = CreateGearboxData(gbxType);
@@ -109,7 +111,7 @@ namespace TUGraz.VectoCore.Tests.Integration
 			{
 				WriteModalResults = true,
 			};
-            var container = new VehicleContainer(ExecutionMode.Engineering, modData) {
+            var container = new VehicleContainer(ExecutionMode.Engineering, modData, summaryDataContainer) {
 				RunData = runData,
 			};
 			var cycle = new DistanceBasedDrivingCycle(container, cycleData);
@@ -125,7 +127,7 @@ namespace TUGraz.VectoCore.Tests.Integration
 
 			var aux = new EngineAuxiliary(container);
 			aux.AddConstant("ZERO", 0.SI<Watt>());
-			container.ModalData.AddAuxiliary("ZERO");
+			container.AddAuxiliary("ZERO");
 
 			engine.Connect(aux.Port());
 
diff --git a/VectoCore/VectoCoreTest/Integration/BatteryElectric/BatteryElectricTest.cs b/VectoCore/VectoCoreTest/Integration/BatteryElectric/BatteryElectricTest.cs
index ee946d1e56..1107b91559 100644
--- a/VectoCore/VectoCoreTest/Integration/BatteryElectric/BatteryElectricTest.cs
+++ b/VectoCore/VectoCoreTest/Integration/BatteryElectric/BatteryElectricTest.cs
@@ -836,11 +836,11 @@ namespace TUGraz.VectoCore.Tests.Integration.BatteryElectric
 			run.Run();
 			Assert.IsTrue(run.FinishedWithoutErrors);
 			Assert.IsTrue(modData.Rows.Count > 0);
-			Assert.That(modData.Columns.Contains(ModalResultField.P_ret_loss.GetName()));
-			Assert.That(modData.Columns.Contains(ModalResultField.P_retarder_in.GetName()));
-			Assert.That(modData.Rows.Cast<DataRow>().All(r => r.Field<Watt>(ModalResultField.P_ret_loss.GetName()) is null));
-			Assert.That(modData.Rows.Cast<DataRow>().All(r => r.Field<Watt>(ModalResultField.P_retarder_in.GetName()) is null));
-		}
+            Assert.IsFalse(modData.Columns.Contains(ModalResultField.P_ret_loss.GetName()));
+            Assert.IsFalse(modData.Columns.Contains(ModalResultField.P_retarder_in.GetName()));
+            //Assert.That(modData.Rows.Cast<DataRow>().All(r => r.Field<Watt>(ModalResultField.P_ret_loss.GetName()) is null));
+            //Assert.That(modData.Rows.Cast<DataRow>().All(r => r.Field<Watt>(ModalResultField.P_retarder_in.GetName()) is null));
+        }
 
 		// =================================================
 
diff --git a/VectoCore/VectoCoreTest/Integration/CoachPowerTrain.cs b/VectoCore/VectoCoreTest/Integration/CoachPowerTrain.cs
index 54cfecfc2e..b8b79b6e11 100644
--- a/VectoCore/VectoCoreTest/Integration/CoachPowerTrain.cs
+++ b/VectoCore/VectoCoreTest/Integration/CoachPowerTrain.cs
@@ -122,7 +122,7 @@ namespace TUGraz.VectoCore.Tests.Integration
 			
 			var aux = new EngineAuxiliary(container);
 			aux.AddConstant("ZERO", 0.SI<Watt>());
-			container.ModalData.AddAuxiliary("ZERO");
+			container.AddAuxiliary("ZERO");
 
 			engine.Connect(aux.Port());
 
diff --git a/VectoCore/VectoCoreTest/Integration/DriverStrategy/SimpleCycles.cs b/VectoCore/VectoCoreTest/Integration/DriverStrategy/SimpleCycles.cs
index 1ed5bdf237..4af313bf0c 100644
--- a/VectoCore/VectoCoreTest/Integration/DriverStrategy/SimpleCycles.cs
+++ b/VectoCore/VectoCoreTest/Integration/DriverStrategy/SimpleCycles.cs
@@ -616,7 +616,7 @@ namespace TUGraz.VectoCore.Tests.Integration.DriverStrategy
 		public void AT_Gearbox_Special(string cycleData, string modFileName)
 		{
 			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
-			var run = ATPowerTrain.CreateEngineeringRun(cycle, GearboxType.ATSerial, modFileName);
+			var run = ATPowerTrain.CreateEngineeringRun(cycle, GearboxType.ATSerial,null, modFileName);
 
 			run.Run();
 			Assert.IsTrue(run.FinishedWithoutErrors);
diff --git a/VectoCore/VectoCoreTest/Integration/EngineOnlyCycle/EngineOnlyCycleTest.cs b/VectoCore/VectoCoreTest/Integration/EngineOnlyCycle/EngineOnlyCycleTest.cs
index 5bca22c3de..1e295ab9a1 100644
--- a/VectoCore/VectoCoreTest/Integration/EngineOnlyCycle/EngineOnlyCycleTest.cs
+++ b/VectoCore/VectoCoreTest/Integration/EngineOnlyCycle/EngineOnlyCycleTest.cs
@@ -112,6 +112,7 @@ namespace TUGraz.VectoCore.Tests.Integration.EngineOnlyCycle
 			var fileWriter = new FileOutputWriter(modFile);
 			var modData = new ModalDataContainer(runData, fileWriter, null) { WriteModalResults = true };
 			modData.AddAuxiliary(Constants.Auxiliaries.Cycle);
+			modData.Data.CreateCombustionEngineColumns(runData);
 			port.Initialize(data.Entries.First().Torque, data.Entries.First().AngularVelocity);
 			foreach (var cycleEntry in data.Entries) {
 				// ReSharper disable once UnusedVariable
diff --git a/VectoCore/VectoCoreTest/Integration/Hybrid/SerialHybridTest.cs b/VectoCore/VectoCoreTest/Integration/Hybrid/SerialHybridTest.cs
index 9dda9a7541..348082cd3b 100644
--- a/VectoCore/VectoCoreTest/Integration/Hybrid/SerialHybridTest.cs
+++ b/VectoCore/VectoCoreTest/Integration/Hybrid/SerialHybridTest.cs
@@ -589,11 +589,11 @@ namespace TUGraz.VectoCore.Tests.Integration.Hybrid
 		{
 			var modData = RunHybridJob(@"TestData\Components\Retarder\S3\S3WithoutAxlegearInputRetarder.vecto", 0);
 			Assert.IsTrue(modData.Rows.Count > 0);
-			Assert.That(modData.Columns.Contains(ModalResultField.P_ret_loss.GetName()));
-			Assert.That(modData.Columns.Contains(ModalResultField.P_retarder_in.GetName()));
-			Assert.That(modData.Rows.Cast<DataRow>().All(r => r.Field<Watt>(ModalResultField.P_ret_loss.GetName()) is null));
-			Assert.That(modData.Rows.Cast<DataRow>().All(r => r.Field<Watt>(ModalResultField.P_retarder_in.GetName()) is null));
-		}
+            Assert.IsFalse(modData.Columns.Contains(ModalResultField.P_ret_loss.GetName()));
+            Assert.IsFalse(modData.Columns.Contains(ModalResultField.P_retarder_in.GetName()));
+            //Assert.That(modData.Rows.Cast<DataRow>().All(r => r.Field<Watt>(ModalResultField.P_ret_loss.GetName()) is null));
+            //Assert.That(modData.Rows.Cast<DataRow>().All(r => r.Field<Watt>(ModalResultField.P_retarder_in.GetName()) is null));
+        }
 
 
 
diff --git a/VectoCore/VectoCoreTest/Integration/Truck40tPowerTrain.cs b/VectoCore/VectoCoreTest/Integration/Truck40tPowerTrain.cs
index e29ad6d0ad..509307fc53 100644
--- a/VectoCore/VectoCoreTest/Integration/Truck40tPowerTrain.cs
+++ b/VectoCore/VectoCoreTest/Integration/Truck40tPowerTrain.cs
@@ -142,7 +142,7 @@ namespace TUGraz.VectoCore.Tests.Integration
 			var aux = new EngineAuxiliary(container);
 			aux.AddConstant("ZERO", 0.SI<Watt>());
 			engine.Connect(aux.Port());
-			container.ModalData.AddAuxiliary("ZERO");
+			container.AddAuxiliary("ZERO");
 
 			return container;
 		}
diff --git a/VectoCore/VectoCoreTest/Models/EngineeringMode/EngineeringModeBusAuxTest.cs b/VectoCore/VectoCoreTest/Models/EngineeringMode/EngineeringModeBusAuxTest.cs
index 0dbc656f2c..9ab509abde 100644
--- a/VectoCore/VectoCoreTest/Models/EngineeringMode/EngineeringModeBusAuxTest.cs
+++ b/VectoCore/VectoCoreTest/Models/EngineeringMode/EngineeringModeBusAuxTest.cs
@@ -940,7 +940,7 @@ namespace TUGraz.VectoCore.Tests.Models.EngineeringMode
 						throw new ArgumentOutOfRangeException("AuxiliaryDemandType", auxData.DemandType.ToString());
 				}
 
-				container.ModalData?.AddAuxiliary(id);
+				container.AddAuxiliary(id);
 			}
 
 			return aux;
diff --git a/VectoCore/VectoCoreTest/Models/Simulation/AuxTests.cs b/VectoCore/VectoCoreTest/Models/Simulation/AuxTests.cs
index d3a81d405e..c9a2b9c4fe 100644
--- a/VectoCore/VectoCoreTest/Models/Simulation/AuxTests.cs
+++ b/VectoCore/VectoCoreTest/Models/Simulation/AuxTests.cs
@@ -205,7 +205,7 @@ namespace TUGraz.VectoCore.Tests.Models.Simulation
 			new MockEngine(container);
 
 			aux.AddCycle("CYCLE");
-			container.ModalData.AddAuxiliary("CYCLE");
+			container.AddAuxiliary("CYCLE");
 
 			var speed = 2358.RPMtoRad();
 			var torque = 500.SI<NewtonMeter>();
diff --git a/VectoCore/VectoCoreTest/Models/Simulation/MockSumWriter.cs b/VectoCore/VectoCoreTest/Models/Simulation/MockSumWriter.cs
index 1eca5dd76a..97ee219ce6 100644
--- a/VectoCore/VectoCoreTest/Models/Simulation/MockSumWriter.cs
+++ b/VectoCore/VectoCoreTest/Models/Simulation/MockSumWriter.cs
@@ -39,5 +39,6 @@ namespace TUGraz.VectoCore.Tests.Models.Simulation
 		public override void Write(IModalDataContainer modData, VectoRunData runData) {}
 
 		public override void Finish() {}
+		public MockSumWriter(ISummaryWriter writer = null) : base(writer) { }
 	}
 }
\ No newline at end of file
diff --git a/VectoCore/VectoCoreTest/Models/Simulation/PwheelModeTests.cs b/VectoCore/VectoCoreTest/Models/Simulation/PwheelModeTests.cs
index 479abf5183..b6023fb482 100644
--- a/VectoCore/VectoCoreTest/Models/Simulation/PwheelModeTests.cs
+++ b/VectoCore/VectoCoreTest/Models/Simulation/PwheelModeTests.cs
@@ -179,7 +179,7 @@ namespace TUGraz.VectoCore.Tests.Models.Simulation
 			};
 
 			// call builder (actual test)
-			var jobContainer = PowertrainBuilder.Build(data, new MockModalDataContainer(), container => {});
+			var jobContainer = PowertrainBuilder.Build(data, new MockModalDataContainer(), new MockSumWriter());
 		}
 
 		/// <summary>
diff --git a/VectoCore/VectoCoreTest/Models/SimulationComponent/ATGearboxTest.cs b/VectoCore/VectoCoreTest/Models/SimulationComponent/ATGearboxTest.cs
index 836f70212e..ec25af829e 100644
--- a/VectoCore/VectoCoreTest/Models/SimulationComponent/ATGearboxTest.cs
+++ b/VectoCore/VectoCoreTest/Models/SimulationComponent/ATGearboxTest.cs
@@ -124,7 +124,7 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 							   200,  0, 0,    2";
 			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
 			var run = ATPowerTrain.CreateEngineeringRun(
-				cycle, gbxType,
+				cycle, gbxType, null,
 				$"AT_Vehicle_Drive-TC-{(gbxType == GearboxType.ATSerial ? "ser" : "ps")}.vmod");
 
 			run.Run();
@@ -140,7 +140,7 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 							  500, 40, 0,    0";
 			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
 			var run = ATPowerTrain.CreateEngineeringRun(
-				cycle, gbxType,
+				cycle, gbxType, null,
 				$"AT_Vehicle_Drive-TC_shiftup-{(gbxType == GearboxType.ATSerial ? "ser" : "ps")}.vmod");
 
 			run.Run();
@@ -156,7 +156,7 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 							  500,  0, 0,    2";
 			var cycle = SimpleDrivingCycles.CreateCycleData(cycleData);
 			var run = ATPowerTrain.CreateEngineeringRun(
-				cycle, gbxType,
+				cycle, gbxType, null,
 				$"AT_Vehicle_Drive-TC_shiftdown-{(gbxType == GearboxType.ATSerial ? "ser" : "ps")}.vmod");
 
 			run.Run();
@@ -179,15 +179,14 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 		{
 			Assert.IsTrue(gbxType.AutomaticTransmission());
 			var cycle = SimpleDrivingCycles.ReadDeclarationCycle(cycleName);
-			var run = ATPowerTrain.CreateEngineeringRun(
-				cycle, gbxType,
-				$"AT_Vehicle_Drive-TC_{cycleName}-{(gbxType == GearboxType.ATSerial ? "ser" : "ps")}.vmod");
-
 			var sumWriter =
 				new SummaryDataContainer(
 					new FileOutputWriter(
 						$"AT_Vehicle_Drive-TC_{cycleName}-{(gbxType == GearboxType.ATSerial ? "ser" : "ps")}"));
-			((VehicleContainer)run.GetContainer()).WriteSumData = sumWriter;
+			var run = ATPowerTrain.CreateEngineeringRun(
+				cycle, gbxType, sumWriter,
+				$"AT_Vehicle_Drive-TC_{cycleName}-{(gbxType == GearboxType.ATSerial ? "ser" : "ps")}.vmod");
+
 			run.Run();
 			sumWriter.Finish();
 			Assert.IsTrue(run.FinishedWithoutErrors);
diff --git a/VectoCore/VectoCoreTest/Models/SimulationComponent/BatteryTest.cs b/VectoCore/VectoCoreTest/Models/SimulationComponent/BatteryTest.cs
index a1da0d0f84..44a1adfd02 100644
--- a/VectoCore/VectoCoreTest/Models/SimulationComponent/BatteryTest.cs
+++ b/VectoCore/VectoCoreTest/Models/SimulationComponent/BatteryTest.cs
@@ -232,6 +232,7 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 			};
 
 			var container = new MockVehicleContainer();
+			var batId = batteryData.Batteries.First().Item2.BatteryId;
 			var bat = new Battery(container, batteryData.Batteries.First().Item2);
 			var es = new ElectricSystem(container);
 			es.Connect(bat);
@@ -248,8 +249,8 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 				Assert.IsInstanceOf<ElectricSystemResponseSuccess>(response);
 				bat.CommitSimulationStep(absTime, dt.SI<Second>(), modData);
 
-				var current = (Ampere)modData[ModalResultField.I_reess];
-				var rREESS = (Watt)modData[ModalResultField.P_reess_loss] / current / current;
+				var current = (Ampere)modData[ModalResultField.I_reess, batId];
+				var rREESS = (Watt)modData[ModalResultField.P_reess_loss, batId] / current / current;
 				Assert.AreEqual(r1, rREESS.Value(), 1e-9, $"{i} / {absTime}");
 				
 				absTime += dt.SI<Second>();
@@ -260,8 +261,8 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 				Assert.IsInstanceOf<ElectricSystemResponseSuccess>(response);
 				bat.CommitSimulationStep(absTime, dt.SI<Second>(), modData);
 
-				var current = (Ampere)modData[ModalResultField.I_reess];
-				var rREESS = (Watt)modData[ModalResultField.P_reess_loss] / current / current;
+				var current = (Ampere)modData[ModalResultField.I_reess, batId];
+				var rREESS = (Watt)modData[ModalResultField.P_reess_loss, batId] / current / current;
 				var slope = (r2 - r1) / (10 - 2);
 				var r = slope * absTime.Value() + r1 - slope * 2;
 				Assert.AreEqual(r, rREESS.Value(), 1e-9, $"{i} / {absTime}");
@@ -274,8 +275,8 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 				Assert.IsInstanceOf<ElectricSystemResponseSuccess>(response);
 				bat.CommitSimulationStep(absTime, dt.SI<Second>(), modData);
 
-				var current = (Ampere)modData[ModalResultField.I_reess];
-				var rREESS = (Watt)modData[ModalResultField.P_reess_loss] / current / current;
+				var current = (Ampere)modData[ModalResultField.I_reess, batId];
+				var rREESS = (Watt)modData[ModalResultField.P_reess_loss, batId] / current / current;
 				var slope = (r3 - r2) / (20 - 10);
 				var r = slope * absTime.Value() + r2 - slope * 10;
 				Assert.AreEqual(r, rREESS.Value(), 1e-9, $"{i} / {absTime}");
@@ -288,8 +289,8 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 				Assert.IsInstanceOf<ElectricSystemResponseSuccess>(response);
 				bat.CommitSimulationStep(absTime, dt.SI<Second>(), modData);
 
-				var current = (Ampere)modData[ModalResultField.I_reess];
-				var rREESS = (Watt)modData[ModalResultField.P_reess_loss] / current / current;
+				var current = (Ampere)modData[ModalResultField.I_reess, batId];
+				var rREESS = (Watt)modData[ModalResultField.P_reess_loss, batId] / current / current;
 				Assert.AreEqual(r3, rREESS.Value(), 1e-9, $"{i} / {absTime}");
 
 				absTime += dt.SI<Second>();
@@ -346,15 +347,18 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 					})
 				}
 			};
-
+			var modData = new MockModalDataContainer();
 			var container = new MockVehicleContainer();
+			container.ModalData = modData;
+
+			var batId = batteryData.Batteries.First().Item2.BatteryId;
 			var bat = new Battery(container, batteryData.Batteries.First().Item2);
 			var es = new ElectricSystem(container);
 			es.Connect(bat);
 			es.Connect(new MockElectricConsumer(0.SI<Watt>()));
 			bat.Initialize(initialSoC);
 
-			var modData = new MockModalDataContainer();
+			
 
 			var absTime = 0.SI<Second>();
 
@@ -372,8 +376,8 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 				Assert.IsInstanceOf<ElectricSystemResponseSuccess>(response);
 				bat.CommitSimulationStep(absTime, dt.SI<Second>(), modData);
 
-				var current = (Ampere)modData[ModalResultField.I_reess];
-				var rREESS = (Watt)modData[ModalResultField.P_reess_loss] / current / current;
+				var current = (Ampere)modData[ModalResultField.I_reess, batId];
+				var rREESS = (Watt)modData[ModalResultField.P_reess_loss, batId] / current / current;
 				Assert.AreEqual(r1, rREESS.Value(), 1e-9, $"{i} / {absTime}");
 
 				absTime += dt.SI<Second>();
@@ -384,8 +388,8 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 				Assert.IsInstanceOf<ElectricSystemResponseSuccess>(response);
 				bat.CommitSimulationStep(absTime, dt.SI<Second>(), modData);
 
-				var current = (Ampere)modData[ModalResultField.I_reess];
-				var rREESS = (Watt)modData[ModalResultField.P_reess_loss] / current / current;
+				var current = (Ampere)modData[ModalResultField.I_reess, batId];
+				var rREESS = (Watt)modData[ModalResultField.P_reess_loss, batId] / current / current;
 				var slope = (r2 - r1) / (10 - 2);
 				var r = slope * (absTime.Value() - 5.5) + r1 - slope * 2;
 				Assert.AreEqual(r, rREESS.Value(), 1e-9, $"{i} / {absTime}");
@@ -398,8 +402,8 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 				Assert.IsInstanceOf<ElectricSystemResponseSuccess>(response);
 				bat.CommitSimulationStep(absTime, dt.SI<Second>(), modData);
 
-				var current = (Ampere)modData[ModalResultField.I_reess];
-				var rREESS = (Watt)modData[ModalResultField.P_reess_loss] / current / current;
+				var current = (Ampere)modData[ModalResultField.I_reess, batId];
+				var rREESS = (Watt)modData[ModalResultField.P_reess_loss, batId] / current / current;
 				var slope = (r3 - r2) / (20 - 10);
 				var r = slope * (absTime.Value() - 5.5) + r2 - slope * 10;
 				Assert.AreEqual(r, rREESS.Value(), 1e-9, $"{i} / {absTime}");
@@ -412,8 +416,8 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 				Assert.IsInstanceOf<ElectricSystemResponseSuccess>(response);
 				bat.CommitSimulationStep(absTime, dt.SI<Second>(), modData);
 
-				var current = (Ampere)modData[ModalResultField.I_reess];
-				var rREESS = (Watt)modData[ModalResultField.P_reess_loss] / current / current;
+				var current = (Ampere)modData[ModalResultField.I_reess, batId];
+				var rREESS = (Watt)modData[ModalResultField.P_reess_loss, batId] / current / current;
 				Assert.AreEqual(r3, rREESS.Value(), 1e-9, $"{i} / {absTime}");
 
 				absTime += dt.SI<Second>();
diff --git a/VectoCore/VectoCoreTest/Models/SimulationComponent/CombustionEngineTest.cs b/VectoCore/VectoCoreTest/Models/SimulationComponent/CombustionEngineTest.cs
index 936f118c78..cac5ae385f 100644
--- a/VectoCore/VectoCoreTest/Models/SimulationComponent/CombustionEngineTest.cs
+++ b/VectoCore/VectoCoreTest/Models/SimulationComponent/CombustionEngineTest.cs
@@ -307,7 +307,7 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 			//vehicleContainer.DataWriter = new ModalDataWriter("engine_idle_test.csv");
 			var dataWriter = new MockModalDataContainer();
 			container.ModData = dataWriter;
-			container.ModalData.AddAuxiliary("CONST");
+			container.AddAuxiliary("CONST");
 
 			var torque = 1200.SI<NewtonMeter>();
 			var angularVelocity = 800.RPMtoRad();
@@ -559,7 +559,7 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
 			//vehicleContainer.DataWriter = new ModalDataWriter("engine_idle_test.csv");
 			var dataWriter = new MockModalDataContainer();
 			container.ModData = dataWriter;
-			container.ModalData.AddAuxiliary("CONST");
+			container.AddAuxiliary("CONST");
 		}
 	}
 }
\ No newline at end of file
diff --git a/VectoCore/VectoCoreTest/Models/SimulationComponentData/ElectricMotorEfficienyMapTest.cs b/VectoCore/VectoCoreTest/Models/SimulationComponentData/ElectricMotorEfficienyMapTest.cs
index a5bf2b56d4..9b0647917d 100644
--- a/VectoCore/VectoCoreTest/Models/SimulationComponentData/ElectricMotorEfficienyMapTest.cs
+++ b/VectoCore/VectoCoreTest/Models/SimulationComponentData/ElectricMotorEfficienyMapTest.cs
@@ -3,8 +3,10 @@ using System.Collections.Generic;
 using System.Data;
 using System.IO;
 using System.Linq;
+using System.Windows.Forms;
 using NUnit.Framework;
 using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.Configuration;
 using TUGraz.VectoCore.InputData.FileIO.JSON;
 using TUGraz.VectoCore.InputData.Reader.ComponentData;
 using TUGraz.VectoCore.Models.SimulationComponent.Data.ElectricMotor;
@@ -51,6 +53,45 @@ namespace TUGraz.VectoCore.Tests.Models.SimulationComponentData {
 			Assert.AreEqual(expectedTq, tq.Value(), 1e-3);
 		}
 
+
+		//[Test]
+		//public void TestMahleEMLookup()
+		//{
+		//	var inputProvider =
+		//		JSONInputDataFactory.ReadElectricMotorData(@"E:\QUAM\Downloads\2022-07-07 Hybrid 40 kW System_sent.7z\2022-07-07 Hybrid 40 kW System_sent\TDS 40kW MTM 48-210x65 V2.04.vem", false);
+
+		//	var pwr = inputProvider.VoltageLevels.Last().PowerMap.First().PowerMap;
+		//	var fld = inputProvider.VoltageLevels.Last().FullLoadCurve;
+		//	var pwrMap = ElectricMotorMapReader.Create(pwr, 1);
+		//	var fldMap = ElectricFullLoadCurveReader.Create(fld, 1);
+
+		//	//var tq = pwrMap.LookupTorque(-45058.6788.SI<Watt>(), 6542.3.RPMtoRad(), -67.0253.SI<NewtonMeter>());
+
+		//	//Assert.AreEqual(-56.72495079, tq.Value(), 1e-6);
+
+		//	var nEm = 4797.89676.RPMtoRad();
+		//	var PEl = 47959.8400.SI<Watt>();
+
+		//	var maxRecupTq = fldMap.FullGenerationTorque(nEm);
+		//	var elPwrRecup = pwrMap.LookupElectricPower(nEm, maxRecupTq);
+
+		//	var recupTq = pwrMap.LookupTorque(PEl, nEm, maxRecupTq);
+
+		//	for (var tq = maxRecupTq - 50.SI<NewtonMeter>();
+		//		tq < maxRecupTq + 50.SI<NewtonMeter>();
+		//		tq += 1.SI<NewtonMeter>()) {
+		//		var pEl = pwrMap.LookupElectricPower(nEm, tq, false);
+		//		if (pEl.ElectricalPower == null) {
+		//			continue;
+		//		}
+		//		Console.WriteLine($"{tq.Value()}, {pEl.ElectricalPower.Value()}, {(pEl.ElectricalPower - PEl).Value()}");
+		//	}
+
+		//	Assert.IsTrue(maxRecupTq > recupTq);
+		//	var elPwr = pwrMap.LookupElectricPower(nEm, recupTq);
+		//	Assert.AreEqual(PEl.Value(), elPwr.ElectricalPower.Value(), Constants.SimulationSettings.InterpolateSearchTolerance);
+		//}
+
 		[TestCase(-1000000, 700), // EM drive has negative torque and thus negative electric power
 		TestCase(1000000, 700)]
 		public void TestLookupTorqueForBatPower2(double batPwr, double emSpeed)
diff --git a/VectoCore/VectoCoreTest/Reports/GearshiftCountTest.cs b/VectoCore/VectoCoreTest/Reports/GearshiftCountTest.cs
index 5be6b5e87d..b6ec7f1b54 100644
--- a/VectoCore/VectoCoreTest/Reports/GearshiftCountTest.cs
+++ b/VectoCore/VectoCoreTest/Reports/GearshiftCountTest.cs
@@ -47,6 +47,7 @@ namespace TUGraz.VectoCore.Tests.Reports
 				JobName = "GearshiftRun"
             };
 			var modData = new ModalDataContainer(rundata, null, null);
+			modData.Data.CreateColumns(ModalResults.GearboxSignals);
 
 			var entries = new[] {
 				new DummyEntry { v = 34, gear = 4u },
@@ -73,6 +74,7 @@ namespace TUGraz.VectoCore.Tests.Reports
 				JobName = "GearshiftRun"
 			};
 			var modData = new ModalDataContainer(rundata, null, null);
+			modData.Data.CreateColumns(ModalResults.GearboxSignals);
 
             var entries = new[] {
 				new DummyEntry { v = 34, gear = 4u },
@@ -99,8 +101,9 @@ namespace TUGraz.VectoCore.Tests.Reports
 				JobName = "GearshiftRun"
 			};
 			var modData = new ModalDataContainer(rundata, null, null);
+			modData.Data.CreateColumns(ModalResults.GearboxSignals);
 
-            var entries = new[] {
+			var entries = new[] {
 				new DummyEntry { v = 34, gear = 4u },
 				new DummyEntry { v = 34.5, gear = 4u },
 				new DummyEntry { v = 33.3, gear = 0 },
@@ -126,8 +129,9 @@ namespace TUGraz.VectoCore.Tests.Reports
 				JobName = "GearshiftRun"
 			};
 			var modData = new ModalDataContainer(rundata, null, null);
+			modData.Data.CreateColumns(ModalResults.GearboxSignals);
 
-            var entries = new[] {
+			var entries = new[] {
 				new DummyEntry { v = 4, gear = 4u },
 				new DummyEntry { v = 3.5, gear = 4u },
 				new DummyEntry { v = 0, gear = 0 },
@@ -152,8 +156,9 @@ namespace TUGraz.VectoCore.Tests.Reports
 				JobName = "GearshiftRun"
 			};
 			var modData = new ModalDataContainer(rundata, null, null);
+			modData.Data.CreateColumns(ModalResults.GearboxSignals);
 
-            var entries = new[] {
+			var entries = new[] {
 				new DummyEntry { v = 4, gear = 4u },
 				new DummyEntry { v = 3.5, gear = 4u },
 				new DummyEntry { v = 0, gear = 0 },
@@ -180,8 +185,9 @@ namespace TUGraz.VectoCore.Tests.Reports
 				JobName = "GearshiftRun"
 			};
 			var modData = new ModalDataContainer(rundata, null, null);
+			modData.Data.CreateColumns(ModalResults.GearboxSignals);
 
-            var entries = new[] {
+			var entries = new[] {
 				new DummyEntry { v = 34, gear = 4u },
 				new DummyEntry { v = 34.5, gear = 4u },
 				new DummyEntry { v = 33.3, gear = 5 },
@@ -207,8 +213,9 @@ namespace TUGraz.VectoCore.Tests.Reports
 				JobName = "GearshiftRun"
 			};
 			var modData = new ModalDataContainer(rundata, null, null);
+			modData.Data.CreateColumns(ModalResults.GearboxSignals);
 
-            var entries = new[] {
+			var entries = new[] {
 				new DummyEntry { v = 34, gear = 4u },
 				new DummyEntry { v = 34.5, gear = 4u },
 				new DummyEntry { v = 33.3, gear = 4 },
diff --git a/VectoCore/VectoCoreTest/Reports/ModDataPostprocessingTest.cs b/VectoCore/VectoCoreTest/Reports/ModDataPostprocessingTest.cs
index 17b74801f4..770c4a50d6 100644
--- a/VectoCore/VectoCoreTest/Reports/ModDataPostprocessingTest.cs
+++ b/VectoCore/VectoCoreTest/Reports/ModDataPostprocessingTest.cs
@@ -20,6 +20,7 @@ using TUGraz.VectoCore.Models.Simulation.Impl;
 using TUGraz.VectoCore.Models.SimulationComponent.Data;
 using TUGraz.VectoCore.Models.SimulationComponent.Data.Battery;
 using TUGraz.VectoCore.Models.SimulationComponent.Data.Engine;
+using TUGraz.VectoCore.Models.SimulationComponent.Impl;
 using TUGraz.VectoCore.OutputData;
 using TUGraz.VectoCore.OutputData.FileIO;
 using TUGraz.VectoCore.Tests.Utils;
@@ -57,6 +58,9 @@ namespace TUGraz.VectoCore.Tests.Reports
 				WriteModalResults = true
 			};
 
+			modData.Data.CreateCombustionEngineColumns(runData);
+			modData.Data.CreateColumns(ModalResults.DriverSignals);
+			modData.Data.CreateColumns(ModalResults.WheelSignals);
 			var fuel = runData.EngineData.Fuels[0];
 
 			var absTime = 0.SI<Second>();
@@ -214,6 +218,9 @@ namespace TUGraz.VectoCore.Tests.Reports
 				WriteModalResults = true
 			};
 
+			modData.Data.CreateCombustionEngineColumns(runData);
+			modData.Data.CreateColumns(ModalResults.DriverSignals);
+			modData.Data.CreateColumns(ModalResults.WheelSignals);
 			var fuel = runData.EngineData.Fuels[0];
 
 			var absTime = 0.SI<Second>();
@@ -236,6 +243,7 @@ namespace TUGraz.VectoCore.Tests.Reports
 				T1 += dt;
 
 				modData[ModalResultField.time] = absTime + dt / 2;
+				//modData[ModalResultField.dist] = i.SI<Meter>();
 				modData[ModalResultField.simulationInterval] = dt;
 
 				modData[ModalResultField.v_act] = 50.KMPHtoMeterPerSecond();
@@ -265,6 +273,7 @@ namespace TUGraz.VectoCore.Tests.Reports
 				T2 += dt;
 
 				modData[ModalResultField.time] = absTime + dt / 2;
+				//modData[ModalResultField.dist] = i.SI<Meter>();
 				modData[ModalResultField.simulationInterval] = dt;
 
 				modData[ModalResultField.v_act] = 50.KMPHtoMeterPerSecond();
@@ -294,6 +303,7 @@ namespace TUGraz.VectoCore.Tests.Reports
 				T3 += dt;
 
 				modData[ModalResultField.time] = absTime + dt / 2;
+				//modData[ModalResultField.dist] = i.SI<Meter>();
 				modData[ModalResultField.simulationInterval] = dt;
 
 				modData[ModalResultField.v_act] = 50.KMPHtoMeterPerSecond();
@@ -368,6 +378,9 @@ namespace TUGraz.VectoCore.Tests.Reports
 				WriteModalResults = true
 			};
 
+			modData.Data.CreateCombustionEngineColumns(runData);
+			modData.Data.CreateColumns(ModalResults.DriverSignals);
+			modData.Data.CreateColumns(ModalResults.WheelSignals);
 			var fuel = runData.EngineData.Fuels[0];
 
 			var absTime = 0.SI<Second>();
@@ -531,6 +544,14 @@ namespace TUGraz.VectoCore.Tests.Reports
 				WriteModalResults = true
 			};
 
+			modData.Data.CreateCombustionEngineColumns(runData);
+			modData.Data.CreateColumns(ModalResults.DriverSignals);
+			modData.Data.CreateColumns(ModalResults.WheelSignals);
+			modData.Data.CreateColumns(ModalResults.DCDCConverterSignals);
+			modData.Data.CreateColumns(ModalResults.BusAuxiliariesSignals);
+			modData.Data.CreateElectricMotorColumns(runData.ElectricMachinesData.FirstOrDefault().Item1, null, ModalResults.ElectricMotorSignals);
+			modData.Data.CreateColumns(ModalResults.BatterySignals);
+
 			var fuel = runData.EngineData.Fuels[0];
 
 			var absTime = 0.SI<Second>();
@@ -744,6 +765,14 @@ namespace TUGraz.VectoCore.Tests.Reports
 				WriteModalResults = true
 			};
 
+			modData.Data.CreateCombustionEngineColumns(runData);
+			modData.Data.CreateColumns(ModalResults.DriverSignals);
+			modData.Data.CreateColumns(ModalResults.WheelSignals);
+			modData.Data.CreateColumns(ModalResults.DCDCConverterSignals);
+			modData.Data.CreateColumns(ModalResults.BusAuxiliariesSignals);
+			modData.Data.CreateElectricMotorColumns(runData.ElectricMachinesData.FirstOrDefault().Item1, null, ModalResults.ElectricMotorSignals);
+			modData.Data.CreateColumns(ModalResults.BatterySignals);
+
 			var fuel = runData.EngineData.Fuels[0];
 
 			var absTime = 0.SI<Second>();
@@ -966,6 +995,11 @@ namespace TUGraz.VectoCore.Tests.Reports
 			var modData = new ModalDataContainer(runData, writer, null) {
 				WriteModalResults = true
 			};
+			modData.Data.CreateCombustionEngineColumns(runData);
+			modData.Data.CreateColumns(ModalResults.DriverSignals);
+			modData.Data.CreateColumns(ModalResults.BusAuxiliariesSignals);
+			modData.Data.CreateColumns(ModalResults.DCDCConverterSignals);
+			modData.Data.CreateColumns(ModalResults.BatterySignals);
 
 			var fuel = runData.EngineData.Fuels[0];
 
@@ -1170,8 +1204,15 @@ namespace TUGraz.VectoCore.Tests.Reports
 			var modData = new ModalDataContainer(runData, writer, null) {
 				WriteModalResults = true
 			};
-			//modData.AddElectricMotor(emPos);
-
+            //modData.AddElectricMotor(emPos);
+
+            modData.Data.CreateCombustionEngineColumns(runData);
+			modData.Data.CreateColumns(ModalResults.DriverSignals);
+			modData.Data.CreateColumns(ModalResults.WheelSignals);
+			modData.Data.CreateColumns(ModalResults.DCDCConverterSignals);
+			modData.Data.CreateColumns(ModalResults.BusAuxiliariesSignals);
+			modData.Data.CreateElectricMotorColumns(runData.ElectricMachinesData.FirstOrDefault().Item1, null, ModalResults.ElectricMotorSignals);
+			modData.Data.CreateColumns(ModalResults.BatterySignals);
 			var fuel = runData.EngineData.Fuels[0];
 
 			var absTime = 0.SI<Second>();
@@ -1355,6 +1396,14 @@ namespace TUGraz.VectoCore.Tests.Reports
 
 			//modData.AddElectricMotor(emPos);
 
+			modData.Data.CreateCombustionEngineColumns(runData);
+			modData.Data.CreateColumns(ModalResults.DriverSignals);
+			modData.Data.CreateColumns(ModalResults.WheelSignals);
+			modData.Data.CreateColumns(ModalResults.DCDCConverterSignals);
+			modData.Data.CreateColumns(ModalResults.BusAuxiliariesSignals);
+			modData.Data.CreateElectricMotorColumns(runData.ElectricMachinesData.FirstOrDefault().Item1, null, ModalResults.ElectricMotorSignals);
+			modData.Data.CreateColumns(ModalResults.BatterySignals);
+
 			var fuel = runData.EngineData.Fuels[0];
 
 			var absTime = 0.SI<Second>();
@@ -1536,6 +1585,14 @@ namespace TUGraz.VectoCore.Tests.Reports
 				WriteModalResults = true
 			};
 
+			modData.Data.CreateCombustionEngineColumns(runData);
+			modData.Data.CreateColumns(ModalResults.DriverSignals);
+			modData.Data.CreateColumns(ModalResults.WheelSignals);
+			modData.Data.CreateColumns(ModalResults.DCDCConverterSignals);
+			modData.Data.CreateColumns(ModalResults.BusAuxiliariesSignals);
+			modData.Data.CreateElectricMotorColumns(runData.ElectricMachinesData.FirstOrDefault().Item1, null, ModalResults.ElectricMotorSignals);
+			modData.Data.CreateColumns(ModalResults.BatterySignals);
+
 			var fuel = runData.EngineData.Fuels[0];
 
 			var absTime = 0.SI<Second>();
@@ -1934,6 +1991,12 @@ namespace TUGraz.VectoCore.Tests.Reports
 				WriteModalResults = true
 			};
 
+			modData.Data.CreateCombustionEngineColumns(runData);
+			modData.Data.CreateColumns(ModalResults.DriverSignals);
+			modData.Data.CreateColumns(ModalResults.WheelSignals);
+			modData.Data.CreateColumns(ModalResults.DCDCConverterSignals);
+			modData.Data.CreateColumns(ModalResults.BusAuxiliariesSignals);
+			modData.Data.CreateColumns(ModalResults.BatterySignals);
 			var fuel = runData.EngineData.Fuels[0];
 
 			var absTime = 0.SI<Second>();
@@ -2058,6 +2121,13 @@ namespace TUGraz.VectoCore.Tests.Reports
 			};
 
 			//modData.AddElectricMotor(emPos);
+			modData.Data.CreateCombustionEngineColumns(runData);
+			modData.Data.CreateColumns(ModalResults.DriverSignals);
+			modData.Data.CreateColumns(ModalResults.WheelSignals);
+			modData.Data.CreateColumns(ModalResults.DCDCConverterSignals);
+			modData.Data.CreateColumns(ModalResults.BusAuxiliariesSignals);
+			modData.Data.CreateElectricMotorColumns(runData.ElectricMachinesData.FirstOrDefault().Item1, null, ModalResults.ElectricMotorSignals);
+			modData.Data.CreateColumns(ModalResults.BatterySignals);
 
 			var fuel = runData.EngineData.Fuels[0];
 
@@ -2204,6 +2274,13 @@ namespace TUGraz.VectoCore.Tests.Reports
 			};
 
 			//modData.AddElectricMotor(emPos);
+			modData.Data.CreateCombustionEngineColumns(runData);
+			modData.Data.CreateColumns(ModalResults.DriverSignals);
+			modData.Data.CreateColumns(ModalResults.WheelSignals);
+			modData.Data.CreateColumns(ModalResults.DCDCConverterSignals);
+			modData.Data.CreateColumns(ModalResults.BusAuxiliariesSignals);
+			modData.Data.CreateElectricMotorColumns(runData.ElectricMachinesData.FirstOrDefault().Item1, null, ModalResults.ElectricMotorSignals);
+			modData.Data.CreateColumns(ModalResults.BatterySignals);
 
 			var fuel = runData.EngineData.Fuels[0];
 
@@ -2351,6 +2428,12 @@ namespace TUGraz.VectoCore.Tests.Reports
 				WriteModalResults = true
 			};
 
+			modData.Data.CreateCombustionEngineColumns(runData);
+			modData.Data.CreateColumns(ModalResults.DriverSignals);
+			modData.Data.CreateColumns(ModalResults.WheelSignals);
+			modData.Data.CreateColumns(ModalResults.DCDCConverterSignals);
+			modData.Data.CreateColumns(ModalResults.BusAuxiliariesSignals);
+			modData.Data.CreateColumns(ModalResults.BatterySignals);
 			var fuel = runData.EngineData.Fuels[0];
 
 			var absTime = 0.SI<Second>();
@@ -2474,7 +2557,12 @@ namespace TUGraz.VectoCore.Tests.Reports
 			var modData = new ModalDataContainer(runData, writer, null) {
 				WriteModalResults = true
 			};
-
+			modData.Data.CreateCombustionEngineColumns(runData);
+			modData.Data.CreateColumns(ModalResults.DriverSignals);
+			modData.Data.CreateColumns(ModalResults.BusAuxiliariesSignals);
+			modData.Data.CreateColumns(ModalResults.DCDCConverterSignals);
+			modData.Data.CreateColumns(ModalResults.BatterySignals);
+			modData.Data.CreateElectricMotorColumns(runData.ElectricMachinesData.First().Item1, null, ModalResults.ElectricMotorSignals);
 			//modData.AddElectricMotor(emPos);
 
 			var fuel = runData.EngineData.Fuels[0];
@@ -2663,6 +2751,9 @@ namespace TUGraz.VectoCore.Tests.Reports
 						}
 					}
 				},
+				Cycle = new DrivingCycleData() {
+					CycleType = CycleType.DistanceBased
+				}
 			};
 
 			if (withBusAux) {
@@ -2687,7 +2778,7 @@ namespace TUGraz.VectoCore.Tests.Reports
 					}
 				};
 				retVal.ElectricMachinesData = new List<Tuple<PowertrainPosition, ElectricMotorData>>() {
-					Tuple.Create(emPos, new ElectricMotorData())
+					Tuple.Create(emPos, new ElectricMotorData() { Overload = new OverloadData() {OverloadBuffer = 0.SI<Joule>()}})
 				};
 			}
 
diff --git a/VectoCore/VectoCoreTest/Reports/ModDataTest.cs b/VectoCore/VectoCoreTest/Reports/ModDataTest.cs
index bb666ad5f1..744c4724a2 100644
--- a/VectoCore/VectoCoreTest/Reports/ModDataTest.cs
+++ b/VectoCore/VectoCoreTest/Reports/ModDataTest.cs
@@ -52,6 +52,7 @@ using Ninject;
 using TUGraz.VectoCore.InputData.FileIO.XML;
 using TUGraz.VectoCore.InputData.Reader.ComponentData;
 using TUGraz.VectoCore.Models.Simulation.Impl.SimulatorFactory;
+using TUGraz.VectoCore.Models.SimulationComponent.Data;
 using TUGraz.VectoCore.Tests.Models.Simulation;
 using TUGraz.VectoCore.Utils;
 
@@ -80,9 +81,13 @@ namespace TUGraz.VectoCore.Tests.Reports
 		public void SumDataTest(double initialSpeedVal, double accVal)
 		{
 			var rundata = new VectoRunData() {
-				JobName = "sumDataTest"
+				JobName = "sumDataTest",
+				Cycle = new DrivingCycleData() {
+					CycleType = CycleType.DistanceBased
+				}
 			};
 			var modData = new ModalDataContainer(rundata, null, null);
+			modData.Data.CreateColumns(ModalResults.DriverSignals);
 			var initalSpeed = initialSpeedVal.KMPHtoMeterPerSecond();
 			var speed = initalSpeed;
 			var dist = 0.SI<Meter>();
@@ -312,18 +317,20 @@ namespace TUGraz.VectoCore.Tests.Reports
 		{
 			var lineCnt = 0;
 			var gearColumn = -1;
+			var iceOnColumn = -1;
 			foreach (var line in File.ReadLines(modFilename)) {
 				lineCnt++;
 				if (lineCnt == 2) {
 					var header = line.Split(',').ToList();
 					gearColumn = header.FindIndex(x => x.StartsWith("Gear"));
+					iceOnColumn = header.FindIndex(x => x.StartsWith("ICE On"));
 				}
 				if (lineCnt <= 2) {
 					continue;
 				}
 				var parts = line.Split(',');
-				for (var i = 0; i < 53; i++) {
-					if (i == gearColumn || i >= parts.Length || string.IsNullOrWhiteSpace(parts[i])) {
+				for (var i = 0; i < 57; i++) {
+					if (i == gearColumn || i == iceOnColumn || i >= parts.Length || string.IsNullOrWhiteSpace(parts[i])) {
 						continue;
 					}
 					var numParts = parts[i].Split('.');
@@ -336,20 +343,24 @@ namespace TUGraz.VectoCore.Tests.Reports
 
 		private void AssertSumDataFormat(string sumFilename)
 		{
-			var first = 2;
-			var sumContainer = new SummaryDataContainer(null);
+			//var first = 2;
+			//var sumContainer = new SummaryDataContainer(null);
 			var ranges = new[] {
 				Tuple.Create(SumDataFields.SPEED, SumDataFields.BRAKING_TIME_SHARE)
 			};
+			var lineCnt = 0;
+			List<string> header = new List<string>();
 			foreach (var line in File.ReadLines(sumFilename)) {
-				if (first > 0) {
-					first--;
+				if (lineCnt == 2) {
+					header = line.Split(',').ToList();
+				}
+				if (lineCnt <= 2) {
 					continue;
 				}
 				var parts = line.Split(',');
 				foreach (var range in ranges) {
-					for (var i = sumContainer.Table.Columns.IndexOf(range.Item1);
-						i <= sumContainer.Table.Columns.IndexOf(range.Item2);
+					for (var i = header.FindIndex(x => x.StartsWith(range.Item1));
+						i <= header.FindIndex(x => x. StartsWith(range.Item2));
 						i++) {
 						if (i >= parts.Length || string.IsNullOrWhiteSpace(parts[i])) {
 							continue;
@@ -456,21 +467,21 @@ namespace TUGraz.VectoCore.Tests.Reports
 				var loading = row[SumDataFields.LOADING].ToString();
 				var eFcMapPos = ((ConvertedSI)row[SumDataFields.E_FCMAP_POS]);
 				var eFcMapNeg = ((ConvertedSI)row[SumDataFields.E_FCMAP_NEG]);
-				var ePowertrainInertia = ((ConvertedSI)row[SumDataFields.E_POWERTRAIN_INERTIA]);
+				var ePowertrainInertia = distanceBased ? ((ConvertedSI)row[SumDataFields.E_POWERTRAIN_INERTIA]) : new ConvertedSI(0, "");
 				var eAux = ((ConvertedSI)row[SumDataFields.E_AUX]);
 				var eClutchLoss = ((ConvertedSI)row[SumDataFields.E_CLUTCH_LOSS]);
-				var eTcLoss = ((ConvertedSI)row[SumDataFields.E_TC_LOSS]);
+				var eTcLoss = row.Table.Columns.Contains(SumDataFields.E_TC_LOSS) ? ((ConvertedSI)row[SumDataFields.E_TC_LOSS]) : new ConvertedSI(0, "");
 				//var eShiftLoss = ((SI)row[SummaryDataContainer.E_SHIFT_LOSS]);
 				var eGbxLoss = ((ConvertedSI)row[SumDataFields.E_GBX_LOSS]);
-				var eRetLoss = ((ConvertedSI)row[SumDataFields.E_RET_LOSS]);
-				var eAngleLoss = ((ConvertedSI)row[SumDataFields.E_ANGLE_LOSS]);
+				var eRetLoss =  ((ConvertedSI)row[SumDataFields.E_RET_LOSS]);
+				var eAngleLoss = row.Table.Columns.Contains(SumDataFields.E_ANGLE_LOSS) ? ((ConvertedSI)row[SumDataFields.E_ANGLE_LOSS]) : new ConvertedSI(0, "");
 				var eAxlLoss = ((ConvertedSI)row[SumDataFields.E_AXL_LOSS]);
-				var eBrakeLoss = ((ConvertedSI)row[SumDataFields.E_BRAKE]);
-				var eVehInertia = ((ConvertedSI)row[SumDataFields.E_VEHICLE_INERTIA]);
+				var eBrakeLoss = distanceBased ? ((ConvertedSI)row[SumDataFields.E_BRAKE]) : new ConvertedSI(0, "");
+				var eVehInertia = distanceBased ? ((ConvertedSI)row[SumDataFields.E_VEHICLE_INERTIA]): new ConvertedSI(0, "");
 				var eWheel = !distanceBased ? ((ConvertedSI)row[SumDataFields.E_WHEEL]) : null;
-				var eAir = ((ConvertedSI)row[SumDataFields.E_AIR]);
-				var eRoll = ((ConvertedSI)row[SumDataFields.E_ROLL]);
-				var eGrad = ((ConvertedSI)row[SumDataFields.E_GRAD]);
+				var eAir = distanceBased ? ((ConvertedSI)row[SumDataFields.E_AIR]) : new ConvertedSI(0, "");
+				var eRoll = distanceBased ?((ConvertedSI)row[SumDataFields.E_ROLL]) : new ConvertedSI(0, "");
+				var eGrad = distanceBased ? ((ConvertedSI)row[SumDataFields.E_GRAD]) : new ConvertedSI(0, "");
 				var cargoVolume = mode == ExecutionMode.Engineering ? 0.0 : ((ConvertedSI)row[SumDataFields.CARGO_VOLUME]);
 
 				var loadingValue = ((ConvertedSI)row[SumDataFields.LOADING]) / 1000;
@@ -592,12 +603,12 @@ namespace TUGraz.VectoCore.Tests.Reports
 				var pLossGbx = (Watt)row[ModalResultField.P_gbx_loss.GetName()];
 				var pGbxIn = (Watt)row[ModalResultField.P_gbx_in.GetName()];
 				var pLossAxle = (Watt)row[ModalResultField.P_axle_loss.GetName()];
-				var pLossAngle = row[ModalResultField.P_angle_loss.GetName()] is DBNull
+				var pLossAngle = !row.Table.Columns.Contains(ModalResultField.P_angle_loss.GetName()) || row[ModalResultField.P_angle_loss.GetName()] is DBNull
 					? 0.SI<Watt>()
 					: (Watt)row[ModalResultField.P_angle_loss.GetName()];
 				var pAxleIn = (Watt)row[ModalResultField.P_axle_in.GetName()];
-				var pLossRet = row[ModalResultField.P_ret_loss.GetName()] is DBNull ? 0.SI<Watt>() : (Watt)row[ModalResultField.P_ret_loss.GetName()];
-				var pRetIn = row[ModalResultField.P_retarder_in.GetName()] is DBNull ? pAxleIn : (Watt)row[ModalResultField.P_retarder_in.GetName()];
+				var pLossRet = !row.Table.Columns.Contains(ModalResultField.P_ret_loss.GetName()) || row[ModalResultField.P_ret_loss.GetName()] is DBNull ? 0.SI<Watt>() : (Watt)row[ModalResultField.P_ret_loss.GetName()];
+				var pRetIn = !row.Table.Columns.Contains(ModalResultField.P_ret_loss.GetName()) || row[ModalResultField.P_retarder_in.GetName()] is DBNull ? pAxleIn : (Watt)row[ModalResultField.P_retarder_in.GetName()];
 				var pGbxInertia = (Watt)row[ModalResultField.P_gbx_inertia.GetName()];
 				var pShiftLoss = row[ModalResultField.P_gbx_shift_loss.GetName()] is DBNull
 					? 0.SI<Watt>()
@@ -646,9 +657,9 @@ namespace TUGraz.VectoCore.Tests.Reports
 						time, distance);
 				}
 
-				var pTC_Loss = (Watt)(row[ModalResultField.P_TC_loss.GetName()] != DBNull.Value
-					? row[ModalResultField.P_TC_loss.GetName()]
-					: 0.SI<Watt>());
+				var pTC_Loss = row.Table.Columns.Contains(ModalResultField.P_TC_loss.GetName()) && row[ModalResultField.P_TC_loss.GetName()] != DBNull.Value
+					? (Watt)row[ModalResultField.P_TC_loss.GetName()]
+					: 0.SI<Watt>();
 
 				var pTCOut = row[ModalResultField.P_clutch_out.GetName()];
 				if (pTCOut != DBNull.Value) {
@@ -743,7 +754,7 @@ namespace TUGraz.VectoCore.Tests.Reports
 				var pLossGbx = (Watt)row[ModalResultField.P_gbx_loss.GetName()];
 				var pGbxIn = (Watt)row[ModalResultField.P_gbx_in.GetName()];
 				var pLossAxle = (Watt)row[ModalResultField.P_axle_loss.GetName()];
-				var pLossAngle = row[ModalResultField.P_angle_loss.GetName()] is DBNull
+				var pLossAngle = !row.Table.Columns.Contains(ModalResultField.P_angle_loss.GetName()) || row[ModalResultField.P_angle_loss.GetName()] is DBNull
 					? 0.SI<Watt>()
 					: (Watt)row[ModalResultField.P_angle_loss.GetName()];
 				var pAxleIn = (Watt)row[ModalResultField.P_axle_in.GetName()];
@@ -808,9 +819,9 @@ namespace TUGraz.VectoCore.Tests.Reports
 
 				//}
 
-				var pTC_Loss = (Watt)(row[ModalResultField.P_TC_loss.GetName()] != DBNull.Value
-					? row[ModalResultField.P_TC_loss.GetName()]
-					: 0.SI<Watt>());
+				var pTC_Loss = row.Table.Columns.Contains(ModalResultField.P_TC_loss.GetName()) && row[ModalResultField.P_TC_loss.GetName()] != DBNull.Value
+					? (Watt)row[ModalResultField.P_TC_loss.GetName()]
+					: 0.SI<Watt>();
 
 				var pTCOut = row[ModalResultField.P_clutch_out.GetName()];
 				if (pTCOut != DBNull.Value) {
diff --git a/VectoCore/VectoCoreTest/Reports/SumWriterTest.cs b/VectoCore/VectoCoreTest/Reports/SumWriterTest.cs
index 04dbe84912..996bdef010 100644
--- a/VectoCore/VectoCoreTest/Reports/SumWriterTest.cs
+++ b/VectoCore/VectoCoreTest/Reports/SumWriterTest.cs
@@ -86,19 +86,31 @@ namespace TUGraz.VectoCore.Tests.Reports
 						FuelData = FuelData.Diesel,
 						ConsumptionMap = FuelConsumptionMapReader.ReadFromFile(@"TestData\Components\12t Delivery Truck.vmap")
 					}}.ToList(),
-					IdleSpeed = 600.RPMtoRad()
+					IdleSpeed = 600.RPMtoRad(),
+					RatedPowerDeclared = 300000.SI<Watt>(),
+					RatedSpeedDeclared = 2000.RPMtoRad(),
+					Displacement = 7.SI(Unit.SI.Liter).Cast<CubicMeter>()
 				},
 				ElectricMachinesData = new List<Tuple<PowertrainPosition, ElectricMotorData>>(),
 				Cycle = new DrivingCycleData() {
 					Name = "MockCycle",
+					CycleType = CycleType.DistanceBased
 				},
 				DriverData = new DriverData() {
 					EngineStopStart = new DriverData.EngineStopStartData()
-				}
-            };
+				},
+			};
 			var modData = new ModalDataContainer(rundata, writer, null);
-
+			modData.Data.CreateCombustionEngineColumns(rundata);
+			modData.Data.CreateColumns(ModalResults.VehicleSignals);
+			modData.Data.CreateColumns(ModalResults.BrakeSignals);
+			modData.Data.CreateColumns(ModalResults.DriverSignals);
+			modData.Data.CreateColumns(ModalResults.WheelSignals);
 			modData.AddAuxiliary("FAN");
+			sumWriter.AddAuxiliary("FAN");
+			sumWriter.CreateColumns(SummaryDataContainer.VehilceColumns);
+			sumWriter.CreateColumns(SummaryDataContainer.BrakeColumns);
+			sumWriter.UpdateTableColumns(rundata.EngineData);
 
 			for (var i = 0; i < 500; i++) {
 				modData[ModalResultField.simulationInterval] = 1.SI<Second>();
@@ -122,6 +134,8 @@ namespace TUGraz.VectoCore.Tests.Reports
 				modData[ModalResultField.P_ice_out] = (i % 2 == 0 ? 1 : -1) * 3000.SI<Watt>();
 
 				modData[ModalResultField.P_ice_fcmap] = 0.SI<Watt>();
+				modData[ModalResultField.P_veh_inertia] = 0.SI<Watt>();
+				modData[ModalResultField.P_wheel_inertia] = 0.SI<Watt>();
 
 				modData.CommitSimulationStep();
 			}
@@ -163,18 +177,31 @@ namespace TUGraz.VectoCore.Tests.Reports
 						FuelData = FuelData.Diesel,
 						ConsumptionMap = FuelConsumptionMapReader.ReadFromFile(@"TestData\Components\12t Delivery Truck.vmap")
 					}}.ToList(),
-					IdleSpeed = 600.RPMtoRad()
+					IdleSpeed = 600.RPMtoRad(),
+					RatedPowerDeclared = 300000.SI<Watt>(),
+					RatedSpeedDeclared = 2000.RPMtoRad(),
+					Displacement = 7.SI(Unit.SI.Liter).Cast<CubicMeter>()
 				},
 				ElectricMachinesData = new List<Tuple<PowertrainPosition, ElectricMotorData>>(),
 				Cycle = new DrivingCycleData() {
 					Name = "MockCycle",
+					CycleType = CycleType.DistanceBased
 				},
 				DriverData = new DriverData() {
 					EngineStopStart = new DriverData.EngineStopStartData()
-				}
+				},
 			};
 			var modData = new ModalDataContainer(rundata, writer, null);
+			modData.Data.CreateCombustionEngineColumns(rundata);
+			modData.Data.CreateColumns(ModalResults.VehicleSignals);
+			modData.Data.CreateColumns(ModalResults.BrakeSignals);
+			modData.Data.CreateColumns(ModalResults.DriverSignals);
+			modData.Data.CreateColumns(ModalResults.WheelSignals);
 			modData.AddAuxiliary("FAN");
+			sumWriter.AddAuxiliary("FAN");
+			sumWriter.CreateColumns(SummaryDataContainer.VehilceColumns);
+			sumWriter.CreateColumns(SummaryDataContainer.BrakeColumns);
+			sumWriter.UpdateTableColumns(rundata.EngineData);
 
 			var timeSteps = new[]
 			{ 0.5.SI<Second>(), 0.3.SI<Second>(), 1.2.SI<Second>(), 12.SI<Second>(), 0.1.SI<Second>() };
diff --git a/VectoCore/VectoCoreTest/TestData/Integration/Buses/FactorMethod/CompletedBus_41-32b.vecto b/VectoCore/VectoCoreTest/TestData/Integration/Buses/FactorMethod/CompletedBus_41-32b.vecto
index cbcb20b77e..e80c1685c8 100644
--- a/VectoCore/VectoCoreTest/TestData/Integration/Buses/FactorMethod/CompletedBus_41-32b.vecto
+++ b/VectoCore/VectoCoreTest/TestData/Integration/Buses/FactorMethod/CompletedBus_41-32b.vecto
@@ -1,12 +1,15 @@
 {
 	"Header": {
-	"CreatedBy": "Markus Quaritsch, IVT, Graz University of Technology",
-	"Date": "2020-02-07T15:06:30.9725917Z",
-	"AppVersion": "2.2",
-	"FileVersion": 7
+		"CreatedBy": "Markus Quaritsch, IVT, Graz University of Technology",
+		"Date": "2020-02-07T15:06:30.9725917Z",
+		"AppVersion": "2.2",
+		"FileVersion": 7
 	},
 	"Body": {
 		"CompletedVehicle": "vecto_vehicle-completed_heavyBus_41.xml",
-		"PrimaryVehicleResults":  "primary_heavyBus group41.RSLT_VIF.xml"
+		"PrimaryVehicleResults": "primary_heavyBus group41.RSLT_VIF.xml"
 	}
-}
\ No newline at end of file
+}
+
+
+
diff --git a/VectoCore/VectoCoreTest/TestData/Integration/Multistage/newVifInterimDiesel.vecto b/VectoCore/VectoCoreTest/TestData/Integration/Multistage/newVifInterimDiesel.vecto
index 8c71148384..0b1e10585e 100644
--- a/VectoCore/VectoCoreTest/TestData/Integration/Multistage/newVifInterimDiesel.vecto
+++ b/VectoCore/VectoCoreTest/TestData/Integration/Multistage/newVifInterimDiesel.vecto
@@ -6,8 +6,10 @@
     "FileVersion": 10
   },
   "Body": {
-    "PrimaryVehicle": "..\\..\\XML\\XMLReaderDeclaration\\SchemaVersion2.4\\vecto_vehicle-primary_heavyBus-sample.xml",
-    "InterimStep": "..\\..\\XML\\XMLReaderDeclaration\\SchemaVersion2.4\\vecto_vehicle-stage_input_full-sample.xml",
+    "PrimaryVehicle": "vecto_vehicle-primary_heavyBus-sample.xml",
+    "InterimStep": "vecto_vehicle-stage_input_full-sample.xml",
     "Completed": false
   }
-}
\ No newline at end of file
+}
+
+
diff --git a/VectoCore/VectoCoreTest/TestData/XML/XMLReaderDeclaration/SchemaVersion2.4/WithoutOptionalEntries/Conventional_primaryBus_AMT_n_opt.xml b/VectoCore/VectoCoreTest/TestData/XML/XMLReaderDeclaration/SchemaVersion2.4/WithoutOptionalEntries/Conventional_primaryBus_AMT_n_opt.xml
index 55e4213577..d19e8a9f3b 100644
--- a/VectoCore/VectoCoreTest/TestData/XML/XMLReaderDeclaration/SchemaVersion2.4/WithoutOptionalEntries/Conventional_primaryBus_AMT_n_opt.xml
+++ b/VectoCore/VectoCoreTest/TestData/XML/XMLReaderDeclaration/SchemaVersion2.4/WithoutOptionalEntries/Conventional_primaryBus_AMT_n_opt.xml
@@ -14,7 +14,7 @@
 		<IdlingSpeed>600</IdlingSpeed>
 		<RetarderType>Losses included in Gearbox</RetarderType>
 		<RetarderRatio>2.000</RetarderRatio>
-		<AngledriveType>Separate Angledrive</AngledriveType>
+		<AngledriveType>None</AngledriveType>
 		<ZeroEmissionVehicle>true</ZeroEmissionVehicle>
 		<ADAS xsi:type="ADAS_Conventional_Type">
 			<EngineStopStart>false</EngineStopStart>
diff --git a/VectoCore/VectoCoreTest/Utils/MockVehicleContainer.cs b/VectoCore/VectoCoreTest/Utils/MockVehicleContainer.cs
index c8deb24c1f..e519daac62 100644
--- a/VectoCore/VectoCoreTest/Utils/MockVehicleContainer.cs
+++ b/VectoCore/VectoCoreTest/Utils/MockVehicleContainer.cs
@@ -265,6 +265,14 @@ namespace TUGraz.VectoCore.Tests.Utils
 		public void AddComponent(VectoSimulationComponent component)
 		{
 			Components.Add(component);
+			ModalData?.RegisterComponent(component);
+
+			//WriteSumData?.RegisterComponent(component, RunData);
+		}
+
+		public void AddAuxiliary(string id, string columnName = null)
+		{
+			ModalData?.AddAuxiliary(id, columnName);
 		}
 
 		public void CommitSimulationStep(Second time, Second simulationInterval)
diff --git a/VectoCore/VectoCoreTest/XML/XMLDeclarationInputv24.cs b/VectoCore/VectoCoreTest/XML/XMLDeclarationInputv24.cs
index c209074e66..7d2257ceb6 100644
--- a/VectoCore/VectoCoreTest/XML/XMLDeclarationInputv24.cs
+++ b/VectoCore/VectoCoreTest/XML/XMLDeclarationInputv24.cs
@@ -266,8 +266,8 @@ namespace TUGraz.VectoCore.Tests.XML
 			
 			//optional test
 			if (testDir == Optional_TESTS_DIR) {
-				Assert.IsNull(vehicle.Components.AngledriveInputData);
-				Assert.IsNull(vehicle.Components.RetarderInputData);
+				Assert.IsNotNull(vehicle.Components.AngledriveInputData);
+				Assert.IsNotNull(vehicle.Components.RetarderInputData);
 				Assert.IsEmpty(vehicle.TorqueLimits);
 			}
 			else {
-- 
GitLab