copy code from 'old' rundata factories into mockup rundata factories to avoid...

copy code from 'old' rundata factories into mockup rundata factories to avoid the 'new' architecture-dependent rundata creation (too complex in the mockup)

VectoCore/VectoCore/Mockup/Simulation/RundataFactories/CompletedBusRunDataFactory.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using TUGraz.VectoCommon.Exceptions;
 using TUGraz.VectoCommon.InputData;
 using TUGraz.VectoCommon.Models;
 using TUGraz.VectoCommon.Utils;
@@ -47,6 +48,66 @@ namespace TUGraz.VectoMockup.Simulation.RundataFactories
         //    return base.VectoRunDataHeavyBusCompleted();
         //}
 
+		protected override IEnumerable<VectoRunData> GetNextRun()
+		{
+			var InputDataProvider = DataProvider.MultistageJobInputData;
+			if (InputDataProvider.JobInputData.PrimaryVehicle.Vehicle.ExemptedVehicle) {
+				return new[] { GetExemptedVectoRunData() };
+			}
+			return VectoRunDataHeavyBusCompleted();
+		}
+
+		protected virtual VectoRunData GetExemptedVectoRunData()
+		{
+			var InputDataProvider = DataProvider.MultistageJobInputData;
+            return new VectoRunData() {
+				Exempted = true,
+				VehicleData = new VehicleData() {
+					ModelName = CompletedVehicle.Model,
+					Manufacturer = CompletedVehicle.Manufacturer,
+					ManufacturerAddress = CompletedVehicle.ManufacturerAddress,
+					VIN = CompletedVehicle.VIN,
+					LegislativeClass = CompletedVehicle.LegislativeClass,
+					RegisteredClass = CompletedVehicle.RegisteredClass,
+					VehicleCode = CompletedVehicle.VehicleCode,
+					CurbMass = CompletedVehicle.CurbMassChassis,
+					GrossVehicleMass = CompletedVehicle.GrossVehicleMassRating,
+					ZeroEmissionVehicle = PrimaryVehicle.ZeroEmissionVehicle,
+					MaxNetPower1 = PrimaryVehicle.MaxNetPower1,
+					InputData = CompletedVehicle
+				},
+				Report = Report,
+				Mission = new Mission() {
+					MissionType = MissionType.ExemptedMission
+				},
+				InputData = InputDataProvider
+			};
+		}
+
+        protected virtual IEnumerable<VectoRunData> VectoRunDataHeavyBusCompleted()
+		{
+			var InputDataProvider = DataProvider.MultistageJobInputData;
+            if (InputDataProvider.JobInputData.PrimaryVehicle.Vehicle.VehicleType ==
+				VectoSimulationJobType.BatteryElectricVehicle) {
+				foreach (var vectoRunData in CreateVectoRunDataForMissions(0, ""))
+					yield return vectoRunData;
+			} else {
+				var engineModes = InputDataProvider.JobInputData.PrimaryVehicle.Vehicle.Components.EngineInputData
+					?.EngineModes;
+
+				for (var modeIdx = 0; modeIdx < engineModes.Count; modeIdx++) {
+					var fuelMode = "single fuel mode";
+					if (engineModes[modeIdx].Fuels.Count > 1) {
+						fuelMode = "dual fuel mode";
+					}
+
+					foreach (var vectoRunData in CreateVectoRunDataForMissions(modeIdx, fuelMode))
+						yield return vectoRunData;
+				}
+			}
+		}
+
+
         protected override VectoRunData CreateVectoRunDataSpecific(Mission mission, KeyValuePair<LoadingType, Tuple<Kilogram, double?>> loading, int modeIdx)
         {
             var cycle = DeclarationData.CyclesCache.GetOrAdd(mission.MissionType, _ => DrivingCycleDataReader.ReadFromStream(mission.CycleFile, CycleType.DistanceBased, "", false));
@@ -106,6 +167,53 @@ namespace TUGraz.VectoMockup.Simulation.RundataFactories
             //return base.CreateVectoRunDataSpecific(mission, loading, modeIdx);
         }
 
+        private IEnumerable<VectoRunData> CreateVectoRunDataForMissions(int modeIdx, string fuelMode)
+        {
+			var InputDataProvider = DataProvider.MultistageJobInputData;
+            foreach (var mission in _segmentCompletedBus.Missions) {
+                foreach (var loading in mission.Loadings) {
+                    var simulationRunData = CreateVectoRunDataSpecific(mission, loading, modeIdx);
+                    if (simulationRunData != null) {
+                        yield return simulationRunData;
+                    }
+
+                    var primarySegment = GetPrimarySegment(PrimaryVehicle);
+                    var primaryMission = primarySegment.Missions.Where(
+                        m => {
+                            return m.BusParameter.DoubleDecker ==
+                                    CompletedVehicle.VehicleCode.IsDoubleDeckerBus() &&
+                                    m.MissionType == mission.MissionType &&
+                                    m.BusParameter.FloorType == CompletedVehicle.VehicleCode.GetFloorType();
+                        }).First();
+                    simulationRunData = CreateVectoRunDataGeneric(
+                        primaryMission,
+                        new KeyValuePair<LoadingType, Tuple<Kilogram, double?>>(loading.Key,
+                            primaryMission.Loadings[loading.Key]),
+                        primarySegment, modeIdx);
+
+                    var primaryResult = InputDataProvider.JobInputData.PrimaryVehicle.GetResult(
+                        simulationRunData.Mission.BusParameter.BusGroup, simulationRunData.Mission.MissionType, fuelMode,
+                        simulationRunData.VehicleData.Loading);
+                    if (primaryResult == null || !primaryResult.ResultStatus.Equals("success")) {
+                        throw new VectoException(
+                            "Failed to find results in PrimaryVehicleReport for vehicle group: {0},  mission: {1}, fuel mode: '{2}', payload: {3}. Make sure PIF and completed vehicle data match!",
+                            simulationRunData.Mission.BusParameter.BusGroup, simulationRunData.Mission.MissionType, fuelMode,
+                            simulationRunData.VehicleData.Loading);
+                    }
+
+                    if (primaryResult.ResultStatus != "success") {
+                        throw new VectoException(
+                            "Simulation results in PrimaryVehicleReport for vehicle group: {0},  mission: {1}, fuel mode: '{2}', payload: {3} not finished successfully.",
+                            simulationRunData.Mission.BusParameter.BusGroup, simulationRunData.Mission.MissionType, fuelMode,
+                            simulationRunData.VehicleData.Loading);
+                    }
+
+                    simulationRunData.PrimaryResult = primaryResult;
+
+                    yield return simulationRunData;
+                }
+            }
+        }
         protected override VectoRunData CreateVectoRunDataGeneric(Mission mission, KeyValuePair<LoadingType, Tuple<Kilogram, double?>> loading, Segment primarySegment, int modeIdx)
         {
             var cycle = DeclarationData.CyclesCache.GetOrAdd(mission.MissionType, _ => DrivingCycleDataReader.ReadFromStream(mission.CycleFile, CycleType.DistanceBased, "", false));

VectoCore/VectoCore/Mockup/Simulation/RundataFactories/MockupLorryVectoRunDataFactory.cs

@@ -32,10 +32,16 @@ namespace TUGraz.VectoMockup.Simulation.RundataFactories
         //protected override IDeclarationDataAdapter DataAdapter { get; }
         protected override IEnumerable<VectoRunData> GetNextRun()
         {
-            var nextRun = base.GetNextRun();
-
+			if (InputDataProvider.JobInputData.Vehicle.ExemptedVehicle) {
+				yield return CreateVectoRunData(InputDataProvider.JobInputData.Vehicle, 0, null, new KeyValuePair<LoadingType, Tuple<Kilogram, double?>>());
+			} else {
+				foreach (var vectoRunData in VectoRunDataTruckNonExempted()) {
+					yield return vectoRunData;
+				}
+			}
 
-            return nextRun;
+   //         var nextRun = base.GetNextRun();
+			//return nextRun;
         }
 
         protected override void InitializeReport()
@@ -61,6 +67,61 @@ namespace TUGraz.VectoMockup.Simulation.RundataFactories
             Report.InitializeReport(powertrainConfig);
         }
 
+		private IEnumerable<VectoRunData> VectoRunDataTruckNonExempted()
+		{
+			switch (InputDataProvider.JobInputData.JobType) {
+				case VectoSimulationJobType.ConventionalVehicle:
+				case VectoSimulationJobType.ParallelHybridVehicle:
+				case VectoSimulationJobType.SerialHybridVehicle:
+                case VectoSimulationJobType.IEPC_S:
+                case VectoSimulationJobType.IHPC:
+					return VectoRunDataConventionalTruckNonExempted();
+				case VectoSimulationJobType.BatteryElectricVehicle:
+                case VectoSimulationJobType.IEPC_E:
+					return VectoRunDataBatteryElectricVehicle();
+				case VectoSimulationJobType.EngineOnlySimulation:
+					break;
+				default:
+					throw new ArgumentOutOfRangeException();
+			}
+			return VectoRunDataConventionalTruckNonExempted();
+
+		}
+
+		private IEnumerable<VectoRunData> VectoRunDataBatteryElectricVehicle()
+		{
+			var vehicle = InputDataProvider.JobInputData.Vehicle;
+			foreach (var mission in _segment.Missions) {
+				foreach (var loading in mission.Loadings) {
+					var simulationRunData = CreateVectoRunData(vehicle, 0, mission, loading);
+					yield return simulationRunData;
+				}
+
+			}
+		}
+
+		private IEnumerable<VectoRunData> VectoRunDataConventionalTruckNonExempted()
+		{
+			var vehicle = InputDataProvider.JobInputData.Vehicle;
+
+			var engine = InputDataProvider.JobInputData.Vehicle.Components.EngineInputData;
+			var engineModes = engine.EngineModes;
+
+			for (var modeIdx = 0; modeIdx < engineModes.Count; modeIdx++) {
+				foreach (var mission in _segment.Missions) {
+					if (mission.MissionType.IsEMS() &&
+						engine.RatedPowerDeclared.IsSmaller(DeclarationData.MinEnginePowerForEMS)) {
+						continue;
+					}
+
+					foreach (var loading in mission.Loadings) {
+						var simulationRunData = CreateVectoRunData(vehicle, modeIdx, mission, loading);
+						yield return simulationRunData;
+					}
+				}
+			}
+		}
+
         protected virtual VectoRunData CreateVectoRunData(IVehicleDeclarationInputData vehicle, int modeIdx, Mission mission,
             KeyValuePair<LoadingType, Tuple<Kilogram, double?>> loading)
         {
@@ -115,11 +176,11 @@ namespace TUGraz.VectoMockup.Simulation.RundataFactories
 
 
 
-        //protected override void Initialize()
-        //{
-        //    _segment = GetSegment(InputDataProvider.JobInputData.Vehicle);
+        protected override void Initialize()
+        {
+            _segment = GetSegment(InputDataProvider.JobInputData.Vehicle);
 
-        //}
+        }
 
         #endregion
 

VectoCore/VectoCore/Mockup/Simulation/RundataFactories/PrimaryBusMockupRunDataFactory.cs

@@ -30,6 +30,75 @@ namespace TUGraz.VectoMockup.Simulation.RundataFactories
 
         #region Overrides of AbstractDeclarationVectoRunDataFactory
 
+		protected override IEnumerable<VectoRunData> GetNextRun()
+		{
+			if (InputDataProvider.JobInputData.Vehicle.VehicleCategory == VehicleCategory.HeavyBusPrimaryVehicle) {
+				if (InputDataProvider.JobInputData.Vehicle.ExemptedVehicle) {
+					yield return CreateVectoRunData(InputDataProvider.JobInputData.Vehicle, null,
+						new KeyValuePair<LoadingType, Tuple<Kilogram, double?>>(), 0);
+				} else {
+					foreach (var vectoRunData in VectoRunDataHeavyBusPrimary()) {
+						yield return vectoRunData;
+					}
+				}
+			}
+
+			foreach (var entry in new List<VectoRunData>()) {
+				yield return entry;
+			}
+		}
+
+		private IEnumerable<VectoRunData> VectoRunDataHeavyBusPrimary()
+		{
+			switch (InputDataProvider.JobInputData.JobType) {
+				case VectoSimulationJobType.ConventionalVehicle:
+				case VectoSimulationJobType.ParallelHybridVehicle:
+				case VectoSimulationJobType.SerialHybridVehicle:
+					return VectoRunDataConventionalHeavyBusPrimaryNonExempted();
+				case VectoSimulationJobType.BatteryElectricVehicle:
+					return VectoRunDataBatteryElectricHeavyBusPrimaryNonExempted();
+				case VectoSimulationJobType.EngineOnlySimulation:
+					break;
+				default:
+					throw new ArgumentOutOfRangeException();
+			}
+			return VectoRunDataConventionalHeavyBusPrimaryNonExempted();
+		}
+
+		private IEnumerable<VectoRunData> VectoRunDataBatteryElectricHeavyBusPrimaryNonExempted()
+		{
+			var vehicle = InputDataProvider.JobInputData.Vehicle;
+			foreach (var mission in _segment.Missions) {
+				foreach (var loading in mission.Loadings) {
+					var simulationRunData = CreateVectoRunData(vehicle, mission, loading, 0);
+					if (simulationRunData == null) {
+						continue;
+					}
+					yield return simulationRunData;
+				}
+
+			}
+		}
+
+		private IEnumerable<VectoRunData> VectoRunDataConventionalHeavyBusPrimaryNonExempted()
+		{
+			var vehicle = InputDataProvider.JobInputData.Vehicle;
+			var engine = vehicle.Components.EngineInputData;
+			var engineModes = engine.EngineModes;
+
+			for (var modeIdx = 0; modeIdx < engineModes.Count; modeIdx++) {
+				foreach (var mission in _segment.Missions) {
+					foreach (var loading in mission.Loadings) {
+						var simulationRunData = CreateVectoRunData(vehicle, mission, loading, modeIdx);
+						if (simulationRunData == null) {
+							continue;
+						}
+						yield return simulationRunData;
+					}
+				}
+			}
+		}
+
         protected override void Initialize()
         {
             _segment = GetSegment(InputDataProvider.JobInputData.Vehicle);
@@ -47,14 +116,14 @@ namespace TUGraz.VectoMockup.Simulation.RundataFactories
             var vehicle = InputDataProvider.JobInputData.Vehicle;
             if (vehicle.ExemptedVehicle)
             {
-                powertrainConfig = CreateVectoRunData(vehicle, 0, null,
-                    new KeyValuePair<LoadingType, Tuple<Kilogram, double?>>());
+                powertrainConfig = CreateVectoRunData(vehicle, null,
+                    new KeyValuePair<LoadingType, Tuple<Kilogram, double?>>(), 0);
             }
             else
             {
                 powertrainConfig = _segment.Missions.Select(
                         mission => CreateVectoRunData(
-                            vehicle, 0, mission, mission.Loadings.First()))
+                            vehicle, mission, mission.Loadings.First(), 0))
                     .FirstOrDefault(x => x != null);
             }
 
@@ -63,9 +132,10 @@ namespace TUGraz.VectoMockup.Simulation.RundataFactories
 
         #region Overrides of DeclarationModePrimaryBusVectoRunDataFactory
 
-        protected virtual VectoRunData CreateVectoRunData(IVehicleDeclarationInputData vehicle, int modeIdx,
-            Mission mission,
-            KeyValuePair<LoadingType, Tuple<Kilogram, double?>> loading)
+        protected override VectoRunData CreateVectoRunData(IVehicleDeclarationInputData vehicle,
+			Mission mission, KeyValuePair<LoadingType, Tuple<Kilogram, double?>> loading,
+			int? modeIdx,
+			VectoRunData.OvcHevMode ovcMode = VectoRunData.OvcHevMode.NotApplicable)
         {
 
             VectoRunData runData;
@@ -233,17 +303,17 @@ namespace TUGraz.VectoMockup.Simulation.RundataFactories
         }
 
 
-        public static CombustionEngineData CreateMockupEngineData(IVehicleDeclarationInputData vehicleData, int modeIdx, TankSystem? tankSystem = null)
+        public static CombustionEngineData CreateMockupEngineData(IVehicleDeclarationInputData vehicleData, int? modeIdx, TankSystem? tankSystem = null)
 		{
 
 			var engine = vehicleData.Components.EngineInputData;
-            if (engine == null)
+            if (engine == null || modeIdx == null)
             {
                 return null;
             }
 
             var engineModes = engine.EngineModes;
-            var engineMode = engineModes[modeIdx];
+            var engineMode = engineModes[modeIdx.Value];
             var fuels = new List<CombustionEngineFuelData>();
             foreach (var fuel in engineMode.Fuels)
             {

VectoCore/VectoCore/Models/Declaration/DeclarationData.cs

@@ -490,6 +490,7 @@ namespace TUGraz.VectoCore.Models.Declaration
 					case BusHVACSystemConfiguration.Unknown:
 					case BusHVACSystemConfiguration.Configuration0:
 						throw new VectoException($"Invalid HVAC Configuration {hvacConfigurationInput}");
+
 					case BusHVACSystemConfiguration.Configuration1 when !hasDriverHP && !hasPassengerHP:
 						return BusHVACSystemConfiguration.Configuration1;