added adc to xml reader

VectoCommon/VectoCommon/Resources/XMLNames.Designer.cs

@@ -60,6 +60,60 @@ namespace TUGraz.VectoCommon.Resources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Ratio.
+        /// </summary>
+        public static string ADC_Ratio {
+            get {
+                return ResourceManager.GetString("ADC_Ratio", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to TorqueLossMap.
+        /// </summary>
+        public static string ADC_TorqueLossMap {
+            get {
+                return ResourceManager.GetString("ADC_TorqueLossMap", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Entry.
+        /// </summary>
+        public static string ADC_TorqueLossMap_Entry {
+            get {
+                return ResourceManager.GetString("ADC_TorqueLossMap_Entry", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to inputSpeed.
+        /// </summary>
+        public static string ADC_TorqueLossMap_InputSpeed {
+            get {
+                return ResourceManager.GetString("ADC_TorqueLossMap_InputSpeed", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to inputTorque.
+        /// </summary>
+        public static string ADC_TorqueLossMap_InputTorque {
+            get {
+                return ResourceManager.GetString("ADC_TorqueLossMap_InputTorque", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to torqueLoss.
+        /// </summary>
+        public static string ADC_TorqueLossMap_TorqueLoss {
+            get {
+                return ResourceManager.GetString("ADC_TorqueLossMap_TorqueLoss", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to CdxA_0.
         /// </summary>

VectoCommon/VectoCommon/Resources/XMLNames.resx

@@ -1788,4 +1788,22 @@
   <data name="Capacitor_MinVoltage" xml:space="preserve">
     <value>MinVoltage</value>
   </data>
+  <data name="ADC_Ratio" xml:space="preserve">
+    <value>Ratio</value>
+  </data>
+  <data name="ADC_TorqueLossMap" xml:space="preserve">
+    <value>TorqueLossMap</value>
+  </data>
+  <data name="ADC_TorqueLossMap_Entry" xml:space="preserve">
+    <value>Entry</value>
+  </data>
+  <data name="ADC_TorqueLossMap_InputSpeed" xml:space="preserve">
+    <value>inputSpeed</value>
+  </data>
+  <data name="ADC_TorqueLossMap_InputTorque" xml:space="preserve">
+    <value>inputTorque</value>
+  </data>
+  <data name="ADC_TorqueLossMap_TorqueLoss" xml:space="preserve">
+    <value>torqueLoss</value>
+  </data>
 </root>
\ No newline at end of file

VectoCore/VectoCore/InputData/FileIO/XML/Declaration/DataProvider/XMLDeclarationAuxiliariesDataProvider.cs

@@ -131,9 +131,11 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider
 
         public new const string XSD_TYPE = "AUX_Conventional_LorryDataType";
 		public const string  XSD_HEV_P_TYPE = "AUX_HEV-P_LorryDataType";
+		public const string XSD_HEV_S_TYPE = "AUX_HEV-S_LorryDataType";
 
 		public new static readonly string QUALIFIED_XSD_TYPE = XMLHelper.CombineNamespace(NAMESPACE_URI.NamespaceName, XSD_TYPE);
 		public static readonly string QUALIFIED_XSD_HEV_P_TYPE = XMLHelper.CombineNamespace(NAMESPACE_URI.NamespaceName, XSD_HEV_P_TYPE);
+		public static readonly string QUALIFIED_XSD_HEV_S_TYPE = XMLHelper.CombineNamespace(NAMESPACE_URI.NamespaceName, XSD_HEV_S_TYPE);
 
 
 		public XMLDeclarationAuxiliariesDataProviderV210_Lorry(

VectoCore/VectoCore/InputData/FileIO/XML/Declaration/DataProvider/XMLElectricMachinesDeclarationInputDataProvider.cs

@@ -45,6 +45,10 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider
 				Count = XmlConvert.ToInt32(GetString(XMLNames.ElectricMachine_Count)),
 				ElectricMachine = ElectricMachineSystemReader.CreateElectricMachineSystem(GetNode(XMLNames.ElectricMachineSystem)),
 			};
+
+			if (ElementExists("ADC"))
+				machineEntry.ADC = ElectricMachineSystemReader.ADCInputData;
+
 			if(ElementExists(XMLNames.ElectricMachine_P2_5GearRatios))
 				SetGearRatios(machineEntry);
 			
@@ -66,6 +70,10 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider
 			}
 		}
 
+		
+
+
+
 		#region Implementation of IXMLElectricMachinesDeclarationInputData
 
 		public IXMLElectricMachineSystemReader ElectricMachineSystemReader { protected get; set; }
@@ -96,4 +104,36 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.DataProvider
 
 		#endregion
 	}
+
+	public class XMLADCDeclarationInputDataV2101 : AbstractCommonComponentType, IXMLADCDeclarationInputData
+	{
+		public static readonly XNamespace NAMESPACE_URI = XMLDefinitions.DECLARATION_DEFINITIONS_NAMESPACE_URI_V2101_JOBS;
+		public const string XSD_TYPE = "ADCDataDeclarationType";
+		public static readonly string QUALIFIED_XSD_TYPE = XMLHelper.CombineNamespace(NAMESPACE_URI.NamespaceName, XSD_TYPE);
+		
+		public XMLADCDeclarationInputDataV2101(XmlNode componentNode, string sourceFile)
+			: base(componentNode, sourceFile)
+		{
+			SourceType = DataSourceType.XMLEmbedded;
 		}
+
+		#region Overrides of AbstractXMLResource
+
+		protected override XNamespace SchemaNamespace => NAMESPACE_URI;
+		protected override DataSourceType SourceType { get; }
+
+		#endregion
+
+		#region Implementation of IADCDeclarationInputData
+
+		public double Ratio => GetDouble(XMLNames.ADC_Ratio);
+
+		public TableData LossMap => ReadTableData(XMLNames.ADC_TorqueLossMap, XMLNames.ADC_TorqueLossMap_Entry,
+			new Dictionary<string, string> {
+				{ XMLNames.ADC_TorqueLossMap_InputSpeed, XMLNames.ADC_TorqueLossMap_InputSpeed },
+				{ XMLNames.ADC_TorqueLossMap_InputTorque, XMLNames.ADC_TorqueLossMap_InputTorque },
+				{ XMLNames.ADC_TorqueLossMap_TorqueLoss, XMLNames.ADC_TorqueLossMap_TorqueLoss },
+			});
+
+		#endregion
+	} }

VectoCore/VectoCore/InputData/FileIO/XML/Declaration/Factory/IDeclarationInjectFactory.cs

@@ -97,6 +97,9 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.Factory
 		IXMLSuperCapDeclarationInputData CreateSuperCapDeclarationInputData(
 			string version, XmlNode componentNode, string sourceFile);
 
+		IXMLADCDeclarationInputData CreateADCDeclarationInputData(
+			string version, XmlNode componentNode, string sourceFile);
+
 		IXMLTorqueConverterDeclarationInputData CreateTorqueconverterData(
 			string version, IXMLDeclarationVehicleData vehicle, XmlNode componentNode, string sourceFile);
 

VectoCore/VectoCore/InputData/FileIO/XML/Declaration/Interfaces/IXMLADCDeclarationInputData.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TUGraz.VectoCommon.InputData;
+
+namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.Interfaces
+{
+	public interface IXMLADCDeclarationInputData  : IADCDeclarationInputData, IXMLResource
+	{
+	}
+}

VectoCore/VectoCore/InputData/FileIO/XML/Declaration/Interfaces/IXMLElectricMachinesDeclarationInputData.cs

@@ -6,7 +6,5 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.Interfaces
 	public interface IXMLElectricMachinesDeclarationInputData : IElectricMachinesDeclarationInputData, IXMLResource
 	{
 		IXMLElectricMachineSystemReader ElectricMachineSystemReader { set; }
-
-		// IXMLADCReader ADCReader { set; }
 	}
 }

VectoCore/VectoCore/InputData/FileIO/XML/Declaration/NinjectModules/XMLDeclarationInputDataV210InjectModule.cs

@@ -78,6 +78,9 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.NinjectModules
 			Bind<IXMLAuxiliariesDeclarationInputData>().To<XMLDeclarationAuxiliariesDataProviderV210_Lorry>().Named(
 				XMLDeclarationAuxiliariesDataProviderV210_Lorry.QUALIFIED_XSD_HEV_P_TYPE);
 
+			Bind<IXMLAuxiliariesDeclarationInputData>().To<XMLDeclarationAuxiliariesDataProviderV210_Lorry>().Named(
+				XMLDeclarationAuxiliariesDataProviderV210_Lorry.QUALIFIED_XSD_HEV_S_TYPE);
+
 			Bind<IXMLAuxiliaryDeclarationInputData>().To<XMLAuxiliaryDeclarationDataProviderV210_Lorry>()
 				.Named(XMLAuxiliaryDeclarationDataProviderV210_Lorry.QUALIFIED_XSD_TYPE);
 
@@ -121,6 +124,10 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.NinjectModules
 			Bind<IXMLSuperCapDeclarationInputData>().To<XMLSuperCapDeclarationInputData>()
 				.Named(XMLSuperCapDeclarationInputData.QUALIFIED_XSD_TYPE);
 
+			Bind<IXMLADCDeclarationInputData>().To<XMLADCDeclarationInputDataV2101>()
+				.Named(XMLADCDeclarationInputDataV2101.QUALIFIED_XSD_TYPE);
+
+
 			Bind<IXMLComponentReader>().To<XMLComponentReaderV210_Lorry>()
 				.Named(XMLComponentReaderV210_Lorry.QUALIFIED_XSD_TYPE);
 

VectoCore/VectoCore/InputData/FileIO/XML/Declaration/Reader/IXMLComponentReader.cs

@@ -77,14 +77,9 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.Reader
 	public interface IXMLElectricMachineSystemReader
 	{
 		IElectricMotorDeclarationInputData CreateElectricMachineSystem(XmlNode electricMachineSystem);
+		IADCDeclarationInputData ADCInputData { get; }
 	}
 
-	public interface IXMLADCReader
-	{
-		IADCDeclarationInputData CreateADCInputData();
-	}
-
-
 	public interface IXMLREESSReader
 	{
 		IREESSPackInputData CreateREESSInputData(XmlNode storageNode, REESSType reessType);

VectoCore/VectoCore/InputData/FileIO/XML/Declaration/Reader/Impl/XMLComponentReader.cs

@@ -305,6 +305,8 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.Reader.Impl
 
 			var electricMachine = Factory.CreateElectricMachinesData(version, Vehicle, componentNode, sourcefile);
 			electricMachine.ElectricMachineSystemReader = Factory.CreateElectricMotorReader(version, Vehicle, componentNode, sourcefile);
+			
+			//electricMachine.ADCReader = Factory.CreateADCReader(version, Vehicle, componentNode, sourcefile);
 			return electricMachine;
 		}
 
@@ -539,6 +541,21 @@ namespace TUGraz.VectoCore.InputData.FileIO.XML.Declaration.Reader.Impl
 			return CreateComponent(XMLNames.ElectricMachineSystem, ElectricMachinesCreator);
 		}
 
+		public virtual IADCDeclarationInputData ADCInputData
+		{
+			get
+			{
+				return CreateComponent("ADC", ADCCreator);
+			}
+		}
+
+
+		protected virtual IADCDeclarationInputData ADCCreator(string version,
+			XmlNode componentNode, string sourcefile)
+		{
+			return Factory.CreateADCDeclarationInputData(version, componentNode, sourcefile);
+		}
+
 		protected virtual IElectricMotorDeclarationInputData ElectricMachinesCreator(string version,
 			XmlNode componentNode, string sourcefile)
 		{

VectoCore/VectoCore/VectoCore.csproj

@@ -174,6 +174,7 @@
     <Compile Include="InputData\FileIO\XML\Declaration\DataProvider\XMLElectricStorageSystemDeclarationInputData.cs" />
     <Compile Include="InputData\FileIO\XML\Declaration\DataProvider\XMLGearData.cs" />
     <Compile Include="InputData\FileIO\XML\Declaration\DataProvider\XMLDeclarationPrimaryVehicleBusResultsInputDataProviderV01.cs" />
+    <Compile Include="InputData\FileIO\XML\Declaration\Interfaces\IXMLADCDeclarationInputData.cs" />
     <Compile Include="InputData\FileIO\XML\Declaration\Interfaces\IXMLAirdragDeclarationInputData.cs" />
     <Compile Include="InputData\FileIO\XML\Declaration\Interfaces\IXMLAngledriveInputData.cs" />
     <Compile Include="InputData\FileIO\XML\Declaration\Interfaces\IXMLApplicationInformationData.cs" />

VectoCore/VectoCoreTest/XML/XMLDeclarationInputv210.cs

@@ -243,8 +243,8 @@ namespace TUGraz.VectoCore.Tests.XML
 			Assert.IsNotNull(vehicle.Components);
 			Assert.IsNotNull(vehicle.Components.EngineInputData);
 
-			TestElectricMachines(vehicle.Components.ElectricMachines);
 			Assert.AreEqual(1, vehicle.Components.ElectricMachines.Entries.Count);
+			TestElectricMachinesData(vehicle.Components.ElectricMachines.Entries.First());
 			Assert.IsNotNull(vehicle.Components.GearboxInputData);
 			TestTorqueConverter(vehicle);
 			Assert.IsNotNull(vehicle.Components.AngledriveInputData);//optional
@@ -267,11 +267,10 @@ namespace TUGraz.VectoCore.Tests.XML
 
 		#region Test Electric Machines Reader
 
-		private void TestElectricMachines(IElectricMachinesDeclarationInputData electricMachines)
+		private void TestElectricMachinesData(ElectricMachineEntry<IElectricMotorDeclarationInputData> eMachineEntry)
 		{
-			Assert.IsNotNull(electricMachines);
-			Assert.AreEqual(1, electricMachines.Entries.Count);
-			var eMachine = electricMachines.Entries.First().ElectricMachine;
+			Assert.IsNotNull(eMachineEntry);
+			var eMachine = eMachineEntry.ElectricMachine;
 
 			Assert.IsNotNull(eMachine);
 			Assert.AreEqual("a", eMachine.Manufacturer);
@@ -594,8 +593,68 @@ namespace TUGraz.VectoCore.Tests.XML
 			Assert.IsNotNull(vehicle.Components.EngineInputData);
 			Assert.IsNotNull(vehicle.Components.ElectricMachines);
 			Assert.AreEqual(2, vehicle.Components.ElectricMachines.Entries.Count);
+			TestElectricMachines(vehicle.Components.ElectricMachines.Entries);
+			Assert.IsNotNull(vehicle.Components.GearboxInputData);
+
+			Assert.IsNotNull(vehicle.Components.AngledriveInputData);//optional
+			Assert.IsNotNull(vehicle.Components.RetarderInputData);//optional
+			Assert.IsNotNull(vehicle.Components.AxleGearInputData);
+			Assert.IsNotNull(vehicle.Components.AxleWheels);
+			Assert.IsNotNull(vehicle.Components.AuxiliaryInputData);
+			Assert.IsNull(vehicle.Components.BusAuxiliaries);
+		}
+
+		private void TestElectricMachines(IList<ElectricMachineEntry<IElectricMotorDeclarationInputData>> eMachines)
+		{
+			foreach (var eMachine in eMachines) {
+				switch (eMachine.Position) {
+					case PowertrainPosition.GEN:
+						TestElectricMachineGEN(eMachine);
+						break;
+					case PowertrainPosition.BatteryElectricE2:
+						TestElectricMachine(eMachine);
+						break;
+				}
+			}
+		}
+
+		private void TestElectricMachineGEN(ElectricMachineEntry<IElectricMotorDeclarationInputData> eMachine)
+		{
+			Assert.AreEqual(1, eMachine.Count);
+			TestElectricMachinesData(eMachine);
+			TestADC(eMachine.ADC);
 		}
 
+		private void TestElectricMachine(ElectricMachineEntry<IElectricMotorDeclarationInputData> eMachine)
+		{
+			Assert.AreEqual(1, eMachine.Count);
+			TestElectricMachinesData(eMachine);
+			TestADC(eMachine.ADC);
+		}
+
+		private void TestADC(IADCDeclarationInputData adcData)
+		{
+			Assert.AreEqual("ADC Manufacturer", adcData.Manufacturer);
+			Assert.AreEqual("ADC Model", adcData.Model);
+			Assert.AreEqual("adcadc", adcData.CertificationNumber);
+			Assert.AreEqual(DateTime.Parse("2017-01-01T00:00:00Z").ToUniversalTime(), adcData.Date);
+			Assert.AreEqual("adccda", adcData.AppVersion);
+			Assert.AreEqual(12.123, adcData.Ratio);
+			Assert.AreEqual(CertificationMethod.Option1, adcData.CertificationMethod);
+			Assert.IsNotNull(adcData.DigestValue);
+
+			TestTorqueLossMapEntry("10.00","40.00" ,"30.00", adcData.LossMap.Rows[0]);
+			TestTorqueLossMapEntry("11.00", "41.00", "31.00", adcData.LossMap.Rows[1]);
+			TestTorqueLossMapEntry("12.00", "41.00", "32.00", adcData.LossMap.Rows[2]);
+			TestTorqueLossMapEntry("13.00", "42.00", "33.00", adcData.LossMap.Rows[3]);
+		}
+
+		private void TestTorqueLossMapEntry(string inputSpeed, string inputTorque, string torqueLoss, DataRow row)
+		{
+			Assert.AreEqual(inputSpeed, row[XMLNames.ADC_TorqueLossMap_InputSpeed]);
+			Assert.AreEqual(inputTorque, row[XMLNames.ADC_TorqueLossMap_InputTorque]);
+			Assert.AreEqual(torqueLoss, row[XMLNames.ADC_TorqueLossMap_TorqueLoss]);
+		}
 
 
 		#region Test existence of torque converter