parsing vehicle data

VectoCore/Models/SimulationComponent/Data/RetarderData.cs

+using System.Runtime.InteropServices;
+using Newtonsoft.Json;
+
+namespace TUGraz.VectoCore.Models.SimulationComponent.Data
+{
+	public class RetarderData : SimulationComponentData
+	{
+		public enum RetarderType
+		{
+			None,
+			Primary,
+			Secondary
+		}
+
+		private readonly Data _data;
+
+		private readonly RetarderType _type;
+
+		public RetarderData(Data data)
+		{
+			_data = data;
+			LossMap = RetarderLossMap.ReadFromFile(_data.File);
+			switch (_data.TypeStr) {
+				case "Primary":
+					_type = RetarderType.Primary;
+					break;
+				case "Secondary":
+					_type = RetarderType.Secondary;
+					break;
+				default:
+					_type = RetarderType.None;
+					break;
+			}
+		}
+
+		public RetarderLossMap LossMap { get; private set; }
+
+		public RetarderType Type
+		{
+			get { return _type; }
+		}
+
+		public double Ratio
+		{
+			get { return _data.Ratio; }
+			set { _data.Ratio = value; }
+		}
+
+		public class Data
+		{
+			[JsonProperty(Required = Required.Always)] public string TypeStr;
+
+			[JsonProperty] public double Ratio;
+
+			[JsonProperty] public string File;
+		}
+	}
+}
\ No newline at end of file

VectoCore/Models/SimulationComponent/Data/VehicleData.cs

+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.Serialization;
+using Newtonsoft.Json;
+using TUGraz.VectoCore.Exceptions;
+using TUGraz.VectoCore.Utils;
+
+namespace TUGraz.VectoCore.Models.SimulationComponent.Data
+{
+	public class VehicleData : SimulationComponentData
+	{
+		public enum VehicleCategory
+		{
+			RigidTruck,
+			Tractor,
+			CityBus,
+			InterurbanBus,
+			Coach
+		}
+
+		public enum CrossWindCorrectionMode
+		{
+			NoCorrection,
+			SpeedDependent,
+			VAirBeta
+		}
+
+		public enum AxleConfiguration
+		{
+			AxleConfig4x2,
+			AxleConfig4x4,
+			AxleConfig6x2,
+			AxleConfig6x4,
+			AxleConfig6x6,
+			AxleConfig8x2,
+			AxleConfig8x4,
+			AxleConfig8x6,
+			AxleConfig8x8,
+		}
+
+		[DataMember] private Data _data;
+
+		[DataMember] private VehicleCategory _vehicleCategory;
+
+		[DataMember] private CrossWindCorrectionMode _crossWindCorrectionMode;
+
+		[DataMember] private RetarderData _retarder;
+
+		[DataMember] private List<Axle> _axleData;
+
+		[DataMember] private AxleConfiguration _axleConfiguration;
+
+
+		public bool SavedInDeclarationMode
+		{
+			get { return _data.Body.SavedInDeclarationMode; }
+			set { _data.Body.SavedInDeclarationMode = value; }
+		}
+
+		public VehicleCategory Category
+		{
+			get { return _vehicleCategory; }
+			protected set { _vehicleCategory = value; }
+		}
+
+		public double CurbWeight
+		{
+			get { return _data.Body.CurbWeight; }
+			set { _data.Body.CurbWeight = value; }
+		}
+
+		public double CurbWeigthExtra
+		{
+			get { return _data.Body.CurbWeightExtra; }
+			set { _data.Body.CurbWeightExtra = value; }
+		}
+
+		public double Loading
+		{
+			get { return _data.Body.Loading; }
+			set { _data.Body.Loading = value; }
+		}
+
+		public Kilogram GrossVehicleMassRating
+		{
+			get { return _data.Body.GrossVehicleMassRating.SI<Kilogram>(); }
+			set { _data.Body.GrossVehicleMassRating = (double) value.ConvertTo().Kilo.Kilo.Gramm; }
+		}
+
+		public double DragCoefficient
+		{
+			get { return _data.Body.DragCoefficient; }
+			set { _data.Body.DragCoefficient = value; }
+		}
+
+		public SquareMeter CrossSectionArea
+		{
+			get { return _data.Body.CrossSectionArea.SI<SquareMeter>(); }
+			set { _data.Body.CrossSectionArea = value.Double(); }
+		}
+
+		public double DragCoefficientRigidTruck
+		{
+			get { return _data.Body.DragCoefficient; }
+			set { _data.Body.DragCoefficient = value; }
+		}
+
+		public SquareMeter CrossSectionAreaRigidTruck
+		{
+			get { return _data.Body.CrossSectionArea.SI<SquareMeter>(); }
+			set { _data.Body.CrossSectionArea = value.Double(); }
+		}
+
+		public Meter DynamicTyreRadius
+		{
+			get { return _data.Body.DynamicTyreRadius.SI().Milli.Meter.Cast<Meter>(); }
+			set { _data.Body.DynamicTyreRadius = (double) value.ConvertTo().Milli.Meter; }
+		}
+
+		public string Rim
+		{
+			get { throw new NotImplementedException(); }
+			set { throw new NotImplementedException(); }
+		}
+
+		public CrossWindCorrectionMode CrossWindCorrection
+		{
+			get { return _crossWindCorrectionMode; }
+			protected set { _crossWindCorrectionMode = value; }
+		}
+
+		public RetarderData Retarder
+		{
+			get { return _retarder; }
+			protected set { _retarder = value; }
+		}
+
+		public AxleConfiguration Axles
+		{
+			get { return _axleConfiguration; }
+		}
+
+		public static VehicleData ReadFromFile(string fileName)
+		{
+			return ReadFromJson(File.ReadAllText(fileName), Path.GetDirectoryName(fileName));
+		}
+
+		public static VehicleData ReadFromJson(string json, string basePath = "")
+		{
+			var vehicleData = new VehicleData();
+
+			var d = JsonConvert.DeserializeObject<Data>(json);
+			if (d.Header.FileVersion > 5) {
+				throw new UnsupportedFileVersionException("Unsupported Version of .vveh file. Got Version " + d.Header.FileVersion);
+			}
+
+			vehicleData._data = d;
+
+			vehicleData._retarder = new RetarderData(d.Body.Retarder);
+
+			vehicleData._axleData = new List<Axle>(d.Body.AxleConfig.Axles.Count);
+			foreach (var axle in d.Body.AxleConfig.Axles) {
+				vehicleData._axleData.Add(new Axle(axle));
+			}
+
+			vehicleData._axleConfiguration = AxleConfiguration.AxleConfig4x2;
+
+			switch (d.Body.VehicleCategoryStr) {
+				case "RigidTruck":
+					vehicleData._vehicleCategory = VehicleCategory.RigidTruck;
+					break;
+				case "Tractor":
+					vehicleData._vehicleCategory = VehicleCategory.Tractor;
+					break;
+				case "CityBus":
+					vehicleData._vehicleCategory = VehicleCategory.CityBus;
+					break;
+				case "InterurbanBus":
+					vehicleData._vehicleCategory = VehicleCategory.InterurbanBus;
+					break;
+				case "Coach":
+					vehicleData._vehicleCategory = VehicleCategory.Coach;
+					break;
+			}
+
+			switch (d.Body.CrossWindCorrectionModeStr) {
+				case "CdOfBeta":
+					vehicleData._crossWindCorrectionMode = CrossWindCorrectionMode.VAirBeta;
+					break;
+				case "CdOfV":
+					vehicleData._crossWindCorrectionMode = CrossWindCorrectionMode.SpeedDependent;
+					break;
+				default:
+					vehicleData._crossWindCorrectionMode = CrossWindCorrectionMode.NoCorrection;
+					break;
+			}
+
+			return vehicleData;
+		}
+
+		public class Data
+		{
+			[JsonProperty(Required = Required.Always)] public JsonDataHeader Header;
+			[JsonProperty(Required = Required.Always)] public DataBody Body;
+
+			public class DataBody
+			{
+				[JsonProperty("SavedInDeclMode")] public bool SavedInDeclarationMode;
+
+				[JsonProperty("VehCat", Required = Required.Always)] public string VehicleCategoryStr;
+
+				[JsonProperty(Required = Required.Always)] public double CurbWeight;
+
+				[JsonProperty] public double CurbWeightExtra;
+
+				[JsonProperty] public double Loading;
+
+				[JsonProperty("MaxMass", Required = Required.Always)] public double GrossVehicleMassRating;
+
+				[JsonProperty("Cd2")] public double DragCoefficientRigidTruck; // without trailer
+
+				[JsonProperty("CrossSecArea2")] public double CrossSectionAreaRigidTruck;
+
+				[JsonProperty("Cd", Required = Required.Always)] public double DragCoefficient;
+
+				[JsonProperty("CrossSecArea", Required = Required.Always)] public double CrossSectionArea;
+
+				[JsonProperty("rdyn")] public double DynamicTyreRadius;
+
+				[JsonProperty("Rim")] public string RimStr;
+
+				[JsonProperty("CdCorrMode")] public string CrossWindCorrectionModeStr;
+
+				[JsonProperty("CdCorrFile")] public string CrossWindCorrectionFile;
+
+				[JsonProperty("Retarder", Required = Required.Always)] public RetarderData.Data Retarder;
+
+				[JsonProperty(Required = Required.Always)] public AxleConfigData AxleConfig;
+
+
+				public class AxleConfigData
+				{
+					[JsonProperty(Required = Required.Always)] public string TypeStr;
+					[JsonProperty(Required = Required.Always)] public IList<AxleData> Axles;
+				}
+
+				public class AxleData
+				{
+					[JsonProperty] public double Inertia;
+					[JsonProperty] public string WheelsStr;
+					[JsonProperty] public double AxleWeightShare;
+					[JsonProperty(Required = Required.Always)] public bool TwinTyres;
+					[JsonProperty("RRCISO", Required = Required.Always)] public double RollResistanceCoefficient;
+					[JsonProperty("FzISO", Required = Required.Always)] public double TyreTestLoad;
+				}
+			}
+		}
+
+		public class Axle
+		{
+			private Data.DataBody.AxleData _data;
+
+			public Axle(Data.DataBody.AxleData data)
+			{
+				_data = data;
+			}
+
+			public double Inertia
+			{
+				get { return _data.Inertia; }
+				set { _data.Inertia = value; }
+			}
+
+			public double RollResistanceCoefficient
+			{
+				get { return _data.RollResistanceCoefficient; }
+				set { _data.RollResistanceCoefficient = value; }
+			}
+		}
+	}
+}
\ No newline at end of file

VectoCore/Models/SimulationComponent/IVehicle.cs

+using TUGraz.VectoCore.Models.Connector.Ports;
+
+namespace TUGraz.VectoCore.Models.SimulationComponent
+{
+	public interface IVehicle : IRoadPortInProvider, IDriverDemandOutProvider, IFvInPort, IDriverDemandOutPort {}
+}
\ No newline at end of file

VectoCore/Models/SimulationComponent/Impl/Vehicle.cs

+using System;
+using TUGraz.VectoCore.Models.Connector.Ports;
+using TUGraz.VectoCore.Utils;
+
+namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
+{
+	public class Vehicle : IVehicle
+	{
+		private IFvOutPort _nextInstance;
+
+
+		public IFvInPort InPort()
+		{
+			throw new NotImplementedException();
+		}
+
+		public IDriverDemandOutPort OutPort()
+		{
+			throw new NotImplementedException();
+		}
+
+		public void Connect(IFvOutPort other)
+		{
+			_nextInstance = other;
+		}
+
+		public IResponse Request(TimeSpan absTime, TimeSpan dt, MeterPerSquareSecond accelleration, Radian gradient)
+		{
+			var force = 0.SI<Newton>();
+			var velocity = 0.SI<MeterPerSecond>();
+			return _nextInstance.Request(absTime, dt, force, velocity);
+		}
+
+		public IResponse Request(TimeSpan absTime, TimeSpan dt, MeterPerSecond velocity, Radian gradient)
+		{
+			throw new NotImplementedException();
+		}
+	}
+}
\ No newline at end of file

VectoCore/Utils/SI.cs

@@ -4,6 +4,7 @@ using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 using TUGraz.VectoCore.Exceptions;
 
@@ -15,12 +16,36 @@ namespace TUGraz.VectoCore.Utils
 		protected MeterPerSecond(double val) : base(val, new SI().Meter.Per.Second) {}
 	}
 
+	public class MeterPerSquareSecond : SIBase<MeterPerSquareSecond>
+	{
+		public MeterPerSquareSecond() : this(0) {}
+		protected MeterPerSquareSecond(double val) : base(val, new SI().Meter.Per.Square.Second) {}
+	}
+
 	public class Second : SIBase<Second>
 	{
 		public Second() : this(0) {}
 		protected Second(double val) : base(val, new SI().Second) {}
 	}
 
+	public class Meter : SIBase<Meter>
+	{
+		public Meter() : this(0) {}
+		protected Meter(double val) : base(val, new SI().Meter) {}
+	}
+
+	public class Kilogram : SIBase<Kilogram>
+	{
+		public Kilogram() : this(0) {}
+		protected Kilogram(double val) : base(val, new SI().Kilo.Gramm) {}
+	}
+
+	public class SquareMeter : SIBase<SquareMeter>
+	{
+		public SquareMeter() : this(0) {}
+		protected SquareMeter(double val) : base(val, new SI().Square.Meter) {}
+	}
+
 	public class Watt : SIBase<Watt>
 	{
 		public Watt() : this(0) {}
@@ -240,7 +265,12 @@ namespace TUGraz.VectoCore.Utils
 			/// <summary>
 			/// Hour
 			/// </summary>
-			h
+			h,
+
+			/// <summary>
+			/// Milli
+			/// </summary>
+			milli
 		}
 
 		/// <summary>
@@ -476,6 +506,7 @@ namespace TUGraz.VectoCore.Utils
 			get { return new SI(new SI(this, toUnit: Unit.k), 0.001, Unit.g, Unit.g); }
 		}
 
+
 		/// <summary>
 		///     [N]
 		/// </summary>
@@ -553,6 +584,11 @@ namespace TUGraz.VectoCore.Utils
 			get { return new SI(this, 60.0, Unit.min, Unit.s); }
 		}
 
+		public SI Milli
+		{
+			get { return new SI(this, 0.001, Unit.milli); }
+		}
+
 		/// <summary>
 		///     Converts to/from 1000 * Basic Unit
 		/// </summary>

VectoCore/VectoCore.csproj

@@ -128,14 +128,18 @@
     <Compile Include="Models\SimulationComponent\Data\Gearbox\ShiftPolygon.cs" />
     <Compile Include="Models\SimulationComponent\Data\Gearbox\TorqueConverterData.cs" />
     <Compile Include="Models\SimulationComponent\Data\JsonDataHeader.cs" />
+    <Compile Include="Models\SimulationComponent\Data\RetarderData.cs" />
     <Compile Include="Models\SimulationComponent\Data\RetarderLossMap.cs" />
+    <Compile Include="Models\SimulationComponent\Data\VehicleData.cs" />
     <Compile Include="Models\SimulationComponent\IClutch.cs" />
     <Compile Include="Models\SimulationComponent\IEngineOnlyDrivingCycle.cs" />
     <Compile Include="Models\SimulationComponent\IDriverDemandDrivingCycle.cs" />
     <Compile Include="Models\SimulationComponent\Impl\AxleGear.cs" />
     <Compile Include="Models\SimulationComponent\Impl\Clutch.cs" />
     <Compile Include="Models\SimulationComponent\Impl\Retarder.cs" />
+    <Compile Include="Models\SimulationComponent\Impl\Vehicle.cs" />
     <Compile Include="Models\SimulationComponent\IPowerTrainComponent.cs" />
+    <Compile Include="Models\SimulationComponent\IVehicle.cs" />
     <Compile Include="Utils\Formulas.cs" />
     <Compile Include="Utils\IntExtensionMethods.cs" />
     <Compile Include="Utils\SI.cs" />