added class to generate generic battery system data

VectoCore/VectoCore/Models/GenericModelData/GenericBusBatteryData.cs

+using System;
+using System.Collections.Generic;
+using System.Data;
+using System.Linq;
+using TUGraz.VectoCommon.InputData;
+using TUGraz.VectoCommon.Resources;
+using TUGraz.VectoCommon.Utils;
+using TUGraz.VectoCore.InputData.Reader.ComponentData;
+using TUGraz.VectoCore.Models.SimulationComponent.Data.Battery;
+using TUGraz.VectoCore.Utils;
+
+namespace TUGraz.VectoCore.Models.GenericModelData
+{
+	public class GenericBusBatteryData
+	{
+		public BatterySystemData CreateBatteryData(IElectricStorageSystemDeclarationInputData batteryData, double initialSOC)
+		{
+			var currentBatteryData = batteryData.ElectricStorageElements
+				.Where(x => x.REESSPack.StorageType == REESSType.Battery).ToList();
+
+			if (currentBatteryData.Count == 0)
+				return null;
+
+			return new BatterySystemData
+			{
+				InitialSoC = initialSOC,
+				Batteries = GetBatteries(currentBatteryData)
+			};
+		}
+
+		private List<Tuple<int, BatteryData>> GetBatteries(List<IElectricStorageDeclarationInputData> currentBatteries)
+		{
+			var result = new List<Tuple<int, BatteryData>>();
+
+			foreach (var currentBattery in currentBatteries) {
+				var entry = new Tuple<int, BatteryData>(currentBattery.StringId,
+					GetBatteryData(currentBattery.REESSPack as IBatteryPackDeclarationInputData));
+				result.Add(entry);
+			}
+			
+			return result;
+		}
+		
+		private BatteryData GetBatteryData(IBatteryPackDeclarationInputData battery)
+		{
+			return new BatteryData {
+				MinSOC = battery.MinSOC.Value,
+				MaxSOC = battery.MaxSOC.Value,
+				MaxCurrent = BatteryMaxCurrentReader.Create(battery.MaxCurrentMap),
+				Capacity = battery.Capacity,
+				InternalResistance = GetGenericInternalResistanceMap(battery),
+				SOCMap = BatterySOCReader.Create(battery.VoltageCurve)
+			};
+		}
+		
+		private InternalResistanceMap GetGenericInternalResistanceMap(IBatteryPackDeclarationInputData battery)
+		{
+			var vNominal = GetNominalVoltage(battery.VoltageCurve);
+			var resistance = 0.0;
+			if (battery.BatteryType == BatteryType.HEBS)
+				resistance = GetHEBSResistance(battery.Capacity.AsAmpHour, vNominal);
+			else if (battery.BatteryType == BatteryType.HPBS)
+				resistance = GetHPBSResistance(battery.Capacity.AsAmpHour, vNominal);
+
+			var columnNumber = battery.InternalResistanceCurve.Columns.Count;
+			return BatteryInternalResistanceReader.Create(GetGenericResistanceDataTable(columnNumber, resistance), true);
+		}
+
+		private DataTable GetGenericResistanceDataTable(int columnNumber, double resistance)
+		{
+			var result = new DataTable();
+
+			for (int r = 0; r < 2; r++) {
+				if (r == 0) {
+					result.Columns.Add(BatteryInternalResistanceReader.Fields.StateOfCharge);
+					result.Columns.Add(BatteryInternalResistanceReader.Fields.InternalResistance_2);
+					result.Columns.Add(BatteryInternalResistanceReader.Fields.InternalResistance_10);
+					result.Columns.Add(BatteryInternalResistanceReader.Fields.InternalResistance_20);
+					if (columnNumber == 5) 
+						result.Columns.Add(BatteryInternalResistanceReader.Fields.InternalResistance_120);
+				}
+
+				var soc = r == 0 ? 0 : 100;
+
+				result.Rows.Add(result.NewRow());
+				result.Rows[r][BatteryInternalResistanceReader.Fields.StateOfCharge] = soc;
+				result.Rows[r][BatteryInternalResistanceReader.Fields.InternalResistance_2] = resistance;
+				result.Rows[r][BatteryInternalResistanceReader.Fields.InternalResistance_10] = resistance;
+				result.Rows[r][BatteryInternalResistanceReader.Fields.InternalResistance_20] = resistance;
+				if (columnNumber == 5)
+					result.Rows[r][BatteryInternalResistanceReader.Fields.InternalResistance_120] = resistance;
+			}
+			
+			return result;
+		}
+
+		private Volt GetNominalVoltage(TableData ocvData)
+		{
+			var sortedOcvData = ocvData.AsEnumerable().OrderBy(x => x.ParseDouble(XMLNames.REESS_OCV_SoC)).ToList();
+
+			for (int i = 0; i < sortedOcvData.Count; i++) {
+
+				var soc = sortedOcvData[i].ParseDouble(XMLNames.REESS_OCV_SoC);
+				if (soc >= 50) {
+
+					int fstIndex;
+					int secIndex;
+					if (i < sortedOcvData.Count - 1) {
+						fstIndex = i;
+						secIndex = i + 1;
+					} else {
+						fstIndex = i - 1;
+						secIndex = i;
+					}
+
+					var fstSoC = sortedOcvData[fstIndex].ParseDouble(XMLNames.REESS_OCV_SoC);
+					var secSoC = sortedOcvData[secIndex].ParseDouble(XMLNames.REESS_OCV_SoC);
+					var fstOCV = sortedOcvData[fstIndex].ParseDouble(XMLNames.REESS_OCV_OCV);
+					var secOCV = sortedOcvData[secIndex].ParseDouble(XMLNames.REESS_OCV_OCV);
+
+					return VectoMath.Interpolate(fstSoC, secSoC, fstOCV, secOCV, 50).SI<Volt>();
+				}
+			}
+
+			return null;
+		}
+		
+		private double GetHPBSResistance(double ratedCapacity, Volt vNominal)
+		{
+			return (25 / ratedCapacity ) * (vNominal.Value() / 3.3);
+		}
+		
+		private double GetHEBSResistance(double ratedCapacity, Volt vNominal)
+		{
+			return (140 / ratedCapacity) * (vNominal.Value() / 3.7);
+		}
+	}
+}