Code development platform for open source projects from the European Union institutions :large_blue_circle: EU Login authentication by SMS has been phased out. To see alternatives please check here

Skip to content
Snippets Groups Projects
Select Git revision
  • 6f102f8f9cf0279a7e034f5aad00898a74605116
  • tug-dev default
  • amdm3/develop
  • fix/scripts1
  • amdm2/develop
  • amdm2/main
  • playground
  • feat/changelog
  • fix/solution_tests
  • test/full_release_process
  • test/art10_test_execution
  • test/gitlab_files_api
  • test/multiplatform_david
  • trgbot
  • set-sast-config-3
  • set-sast-config-2
  • set-secret-detection-config-2
  • set-secret-detection-config-1
  • set-sast-config-1
  • test-linux-fixes
  • tug-stable
  • Release/v4.3.2
  • v1.0.1
  • v1.0.0
  • Build/v0.7.10.2996
  • v0.7.5b0+2524.multistep
  • Release/v3.3.14.2981-RC
  • Build/v0.7.9.2975
  • Release/v3.3.13.2924
  • Release/v3.3.13.2891-RC
  • Build/0.7.9.2890
  • Build/v0.7.9.2864
  • Build/v0.7.9.2849
  • Build/v0.7.9.2836
  • Release/TrailerTool_V0.9.0.2759
  • Release/TrailerTool_V0.9.0.2735
  • Release/TrailerTool_V0.9.0.2799
  • Release/v3.3.12.2800
  • Release/v3.3.12.2769-RC
  • Build/v0.7.9.2741
  • Build/v0.5.0.1812_VectoFF
41 results

EngineFullLoadCurve.cs

Blame
  • Forked from VECTO / VECTO Sim
    Source project has a limited visibility.
    Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    EngineeringDataAdapter.cs 7.07 KiB
    using System.IO;
    using System.Linq;
    using TUGraz.VectoCore.Exceptions;
    using TUGraz.VectoCore.FileIO.EngineeringFile;
    using TUGraz.VectoCore.Models.Declaration;
    using TUGraz.VectoCore.Models.Simulation.Data;
    using TUGraz.VectoCore.Models.SimulationComponent.Data;
    using TUGraz.VectoCore.Models.SimulationComponent.Data.Engine;
    using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
    using TUGraz.VectoCore.Utils;
    
    namespace TUGraz.VectoCore.FileIO.Reader.DataObjectAdaper
    {
    	public class EngineeringDataAdapter : AbstractSimulationDataAdapter
    	{
    		public override VehicleData CreateVehicleData(VectoVehicleFile vehicle, Mission mission,
    			Kilogram loading)
    		{
    			return CreateVehicleData(vehicle);
    		}
    
    		public override VehicleData CreateVehicleData(VectoVehicleFile vehicle)
    		{
    			var fileV7Eng = vehicle as VehicleFileV7Engineering;
    			if (fileV7Eng != null) {
    				return CreateVehicleData(fileV7Eng);
    			}
    			throw new VectoException("Unsupported EngineData File Instance");
    		}
    
    		public override CombustionEngineData CreateEngineData(VectoEngineFile engine)
    		{
    			var fileV2Eng = engine as EngineFileV3Engineering;
    			if (fileV2Eng != null) {
    				return CreateEngineData(fileV2Eng);
    			}
    			throw new VectoException("Unsupported EngineData File Instance");
    		}
    
    		public override GearboxData CreateGearboxData(VectoGearboxFile gearbox, CombustionEngineData engine)
    		{
    			var fileV5Eng = gearbox as GearboxFileV5Engineering;
    			if (fileV5Eng != null) {
    				return CreateGearboxData(fileV5Eng, engine);
    			}
    			throw new VectoException("Unsupported GearboxData File Instance");
    		}
    
    		public override DriverData CreateDriverData(VectoJobFile job)
    		{
    			var filev2Eng = job as VectoJobFileV2Engineering;
    			if (filev2Eng != null) {
    				return CreateDriverData(filev2Eng);
    			}
    			throw new VectoException("Unsupported Job File Instance");
    		}
    
    		//=================================
    
    		internal DriverData CreateDriverData(VectoJobFileV2Engineering job)
    		{
    			var data = job.Body;
    
    			var accelerationData = AccelerationCurveData.ReadFromFile(Path.Combine(job.BasePath, data.AccelerationCurve));
    			var lookAheadData = new DriverData.LACData {
    				Enabled = data.LookAheadCoasting.Enabled,
    				Deceleration = data.LookAheadCoasting.Dec.SI<MeterPerSquareSecond>(),
    				MinSpeed = data.LookAheadCoasting.MinSpeed.KMPHtoMeterPerSecond(),
    			};
    			var overspeedData = new DriverData.OverSpeedEcoRollData {
    				Mode = DriverData.ParseDriverMode(data.OverSpeedEcoRoll.Mode),
    				MinSpeed = data.OverSpeedEcoRoll.MinSpeed.KMPHtoMeterPerSecond(),
    				OverSpeed = data.OverSpeedEcoRoll.OverSpeed.KMPHtoMeterPerSecond(),
    				UnderSpeed = data.OverSpeedEcoRoll.UnderSpeed.KMPHtoMeterPerSecond(),
    			};
    			var startstopData = new VectoRunData.StartStopData {
    				Enabled = data.StartStop.Enabled,
    				Delay = data.StartStop.Delay.SI<Second>(),
    				MinTime = data.StartStop.MinTime.SI<Second>(),
    				MaxSpeed = data.StartStop.MaxSpeed.KMPHtoMeterPerSecond(),
    			};
    			var retVal = new DriverData {
    				AccelerationCurve = accelerationData,
    				LookAheadCoasting = lookAheadData,
    				OverSpeedEcoRoll = overspeedData,
    				StartStop = startstopData,
    			};
    			return retVal;
    		}
    
    		/// <summary>
    		/// convert datastructure representing file-contents into internal datastructure
    		/// Vehicle, file-format version 5
    		/// </summary>
    		/// <param name="vehicle">VehicleFileV5 container</param>
    		/// <returns>VehicleData instance</returns>
    		internal VehicleData CreateVehicleData(VehicleFileV7Engineering vehicle)
    		{
    			var data = vehicle.Body;
    
    			var retVal = SetCommonVehicleData(data, vehicle.BasePath);
    
    			retVal.BasePath = vehicle.BasePath;
    			retVal.CurbWeigthExtra = data.CurbWeightExtra.SI<Kilogram>();
    			retVal.Loading = data.Loading.SI<Kilogram>();
    			retVal.DynamicTyreRadius = data.DynamicTyreRadius.SI().Milli.Meter.Cast<Meter>();
    
    			retVal.CrossWindCorrectionMode = CrossWindCorrectionModeHelper.Parse(data.CrossWindCorrectionModeStr);
    			retVal.AerodynamicDragAera = data.DragCoefficient.SI<SquareMeter>();
    
    			retVal.AxleData = data.AxleConfig.Axles.Select(axle => new Axle {
    				Inertia = axle.Inertia.SI<KilogramSquareMeter>(),
    				TwinTyres = axle.TwinTyres,
    				RollResistanceCoefficient = axle.RollResistanceCoefficient,
    				AxleWeightShare = axle.AxleWeightShare,
    				TyreTestLoad = axle.TyreTestLoad.SI<Newton>(),
    				//Wheels = axle.WheelsStr
    			}).ToList();
    			return retVal;
    		}
    
    
    		/// <summary>
    		/// convert datastructure representing the file-contents into internal data structure
    		/// Engine, file-format version 2
    		/// </summary>
    		/// <param name="engine">Engin-Data file (Engineering mode)</param>
    		/// <returns></returns>
    		internal CombustionEngineData CreateEngineData(EngineFileV3Engineering engine)
    		{
    			var retVal = SetCommonCombustionEngineData(engine.Body, engine.BasePath);
    			retVal.Inertia = engine.Body.Inertia.SI<KilogramSquareMeter>();
    			retVal.FullLoadCurve = EngineFullLoadCurve.ReadFromFile(Path.Combine(engine.BasePath, engine.Body.FullLoadCurve));
    			retVal.FullLoadCurve.EngineData = retVal;
    			return retVal;
    		}
    
    
    		/// <summary>
    		/// convert datastructure representing the file-contents into internal data structure
    		/// Gearbox, File-format Version 4
    		/// </summary>
    		/// <param name="gearbox"></param>
    		/// <param name="engineData"></param>
    		/// <returns></returns>
    		internal GearboxData CreateGearboxData(GearboxFileV5Engineering gearbox, CombustionEngineData engineData)
    		{
    			var retVal = SetCommonGearboxData(gearbox.Body);
    
    			var data = gearbox.Body;
    
    			retVal.Inertia = data.Inertia.SI<KilogramSquareMeter>();
    			retVal.TractionInterruption = data.TractionInterruption.SI<Second>();
    			retVal.SkipGears = data.SkipGears;
    			retVal.EarlyShiftUp = data.EarlyShiftUp;
    			retVal.TorqueReserve = data.TorqueReserve;
    			retVal.StartTorqueReserve = data.StartTorqueReserve;
    			retVal.ShiftTime = data.ShiftTime.SI<Second>();
    			retVal.StartSpeed = data.StartSpeed.SI<MeterPerSecond>();
    			retVal.StartAcceleration = data.StartAcceleration.SI<MeterPerSquareSecond>();
    
    			retVal.HasTorqueConverter = data.TorqueConverter.Enabled;
    
    			var engineFullLoadCurve = (engineData != null) ? engineData.FullLoadCurve : null;
    
    
    			for (uint i = 0; i < gearbox.Body.Gears.Count; i++) {
    				var gearSettings = gearbox.Body.Gears[(int)i];
    				var lossMapPath = Path.Combine(gearbox.BasePath, gearSettings.LossMap);
    				var lossMap = TransmissionLossMap.ReadFromFile(lossMapPath, gearSettings.Ratio);
    
    				var shiftPolygon = string.IsNullOrEmpty(gearSettings.ShiftPolygon)
    					? null
    					: ShiftPolygon.ReadFromFile(Path.Combine(gearbox.BasePath, gearSettings.ShiftPolygon));
    				var fullLoad = string.IsNullOrEmpty(gearSettings.FullLoadCurve) || gearSettings.FullLoadCurve.Equals("<NOFILE>")
    					? null
    					: FullLoadCurve.ReadFromFile(Path.Combine(gearbox.BasePath, gearSettings.FullLoadCurve));
    
    				var gear = new GearData {
    					LossMap = lossMap,
    					ShiftPolygon = shiftPolygon,
    					FullLoadCurve = fullLoad ?? engineFullLoadCurve,
    					Ratio = gearSettings.Ratio,
    					TorqueConverterActive = gearSettings.TCactive
    				};
    				if (i == 0) {
    					retVal.AxleGearData = gear;
    				} else {
    					retVal.Gears.Add(i, gear);
    				}
    			}
    			return retVal;
    		}
    	}
    }