adding testcase and model for electric motor with 2 voltage levels

VECTO/GUI/ElectricMotorForm.vb

@@ -186,12 +186,14 @@ Public Class ElectricMotorForm
         tbDragTorqueHi.Text = GetRelativePath(voltageLevelHigh.DragCurve.Source, basePath)
         tbMaxTorqueHi.Text = GetRelativePath(voltageLevelHigh.FullLoadCurve.Source, basePath)
         tbMapHi.Text = GetRelativePath(voltageLevelHigh.EfficiencyMap.Source, basePath)
+        tbVoltageHi.Text = voltageLevelHigh.VoltageLevel.Value().ToGUIFormat()
 
         Dim voltageLevelLow As IElectricMotorVoltageLevel = engine.VoltageLevels.MinBy(function(level) level.VoltageLevel.Value())
 
         tbDragTorqueLow.Text = GetRelativePath(voltageLevelLow.DragCurve.Source, basePath)
         tbMaxTorqueLow.Text = GetRelativePath(voltageLevelLow.FullLoadCurve.Source, basePath)
         tbMapLow.Text = GetRelativePath(voltageLevelLow.EfficiencyMap.Source, basePath)
+        tbVoltageLow.Text = voltageLevelLow.VoltageLevel.Value().ToGUIFormat()
         
         DeclInit()
 
@@ -234,9 +236,15 @@ Public Class ElectricMotorForm
         em.ContTq = tbContTq.Text.ToDouble(0)
         em.OverloadRecoveryFactor = tbOverloadRecoveryFactor.Text.ToDouble(0)
 
+        em.PathMaxTorqueLow = tbMaxTorqueLow.Text
+        em.PathDragLow = tbDragTorqueLow.Text
+        em.PathMapLow = tbMapLow.Text
+        em.VoltageLevelLow = tbVoltageLow.Text.ToDouble(0)
+
         em.PathMaxTorqueHi = tbMaxTorqueHi.Text
         em.PathDragHi = tbDragTorqueHi.Text
         em.PathMapHi = tbMapHi.Text
+        em.VoltageLevelHigh = tbVoltageHi.Text.ToDouble(0)
 
         If Not em.SaveFile Then
             MsgBox("Cannot save to " & file, MsgBoxStyle.Critical)

VectoCore/VectoCore/Models/SimulationComponent/Data/ElectricMotor/EfficiencyMap.cs

@@ -173,7 +173,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data.ElectricMotor
 			return null;
 		}
 
-		protected PerSecond MaxSpeed
+		public PerSecond MaxSpeed
 		{
 			get { return _maxSpeed ?? (_maxSpeed = _efficiencyMapMech2El.Entries.Select(x => x.Y).Max().SI<PerSecond>()); }
 		}

VectoCore/VectoCore/Models/SimulationComponent/Data/ElectricMotor/ElectricMotorData.cs

@@ -5,6 +5,7 @@ using TUGraz.VectoCommon.Utils;
 using TUGraz.VectoCore.Models.SimulationComponent.Data.ElectricMotor;
 using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
 using TUGraz.VectoCore.Models.SimulationComponent.Impl;
+using TUGraz.VectoCore.Utils;
 
 namespace TUGraz.VectoCore.Models.SimulationComponent.Data
 {
@@ -54,7 +55,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data
 			get
 			{
 				return _maxSpeed ?? (_maxSpeed = VoltageLevels
-					.Min(v => v.FullLoadCurve.FullLoadEntries.MaxBy(x => x.MotorSpeed).MotorSpeed));
+					.Min(v => v.EfficiencyMap.MaxSpeed));
 			}
 		}
 
@@ -83,12 +84,20 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data
 			var retVal = VectoMath.Interpolate(tuple.Item1.Voltage, tuple.Item2.Voltage,
 				r1, r2, voltage);
 			var elPwr = LookupElectricPower(voltage, avgSpeed, retVal, true);
-			if (elPwr.ElectricalPower != null && electricPower.IsEqual(elPwr.ElectricalPower)) {
+			if (elPwr.ElectricalPower != null && electricPower.IsEqual(elPwr.ElectricalPower, 1e-3.SI<Watt>())) {
 				return retVal;
 			}
 
+			var searchResult = SearchAlgorithm.Search(retVal, electricPower - elPwr.ElectricalPower,
+				interval: 10.SI<NewtonMeter>(), 
+				getYValue: x => (Watt)x,
+				evaluateFunction: x => LookupElectricPower(voltage, avgSpeed, x, true).ElectricalPower,
+				criterion: x => ((Watt)x).Value()
+			);
+
+			return searchResult;
 			//return null;
-			throw new NotImplementedException("EfficientyMapLookupTorque");
+			//throw new NotImplementedException("EfficientyMapLookupTorque");
 		}
 
 		public EfficiencyMap.EfficiencyResult LookupElectricPower(Volt voltage, PerSecond avgSpeed, NewtonMeter torque, bool allowExtrapolation = false)

VectoCore/VectoCore/Models/SimulationComponent/Impl/ElectricMotor.cs

@@ -30,7 +30,6 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 
 		protected internal Joule ThermalBuffer = 0.SI<Joule>();
 		protected internal bool DeRatingActive = false;
-		private bool BatteryElectricPowertrain;
 		
 		public Joule OverloadBuffer { get; }
 		public NewtonMeter ContinuousTorque { get; }
@@ -117,9 +116,6 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
 			PreviousState.DrivetrainSpeed = outAngularVelocity;
 			PreviousState.DrivetrainOutTorque = outTorque;
 
-			BatteryElectricPowertrain = !DataBus.PowertrainInfo.HasCombustionEngine &&
-										DataBus.PowertrainInfo.ElectricMotorPositions.All(x => x.IsBatteryElectric());
-
 			if (NextComponent == null) {
 				return new ResponseSuccess(this) {
 					Engine = {

VectoCore/VectoCore/Models/SimulationComponent/Strategies/HybridStrategy.cs

@@ -1936,7 +1936,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Strategies
 				for (var u = stepSize; u <= 1.0; u += stepSize) {
 					var emTorque = firstResponse.ElectricMotor.MaxRecuperationTorque * u;
 					if (!(emTorque).IsBetween(
-						firstResponse.ElectricMotor.MaxRecuperationTorque, firstResponse.ElectricMotor.MaxDriveTorque)) {
+						firstResponse.ElectricMotor.MaxRecuperationTorque, firstResponse.ElectricMotor.MaxDriveTorque ?? 0.SI<NewtonMeter>())) {
 						continue;
 					}
 

VectoCore/VectoCoreTest/FileIO/JsonReadHybridTest.cs

@@ -6,6 +6,7 @@ using TUGraz.VectoCommon.Models;
 using TUGraz.VectoCommon.Utils;
 using TUGraz.VectoCore.InputData.FileIO.JSON;
 using TUGraz.VectoCore.InputData.Reader.ComponentData;
+using TUGraz.VectoCore.InputData.Reader.DataObjectAdapter;
 using TUGraz.VectoCore.Models.Simulation.Impl;
 using TUGraz.VectoCore.Models.SimulationComponent.Impl;
 using TUGraz.VectoCore.OutputData;
@@ -80,6 +81,93 @@ namespace TUGraz.VectoCore.Tests.FileIO
 
         }
 
+		[TestCase()]
+		public void TestReadElectricMotorV3()
+		{
+			var inputProvider =
+				JSONInputDataFactory.ReadElectricMotorData(@"TestData\Hybrids\ElectricMotor\GenericEMotorV3.vem", false);
+
+			Assert.AreEqual(0.15, inputProvider.Inertia.Value(), 1e-6);
+
+			Assert.AreEqual(400, inputProvider.VoltageLevels[0].VoltageLevel.Value());
+
+			var fldLow = inputProvider.VoltageLevels.First().FullLoadCurve;
+			Assert.AreEqual("0", fldLow.Rows[0][ElectricFullLoadCurveReader.Fields.MotorSpeed]);
+			Assert.AreEqual("401.07", fldLow.Rows[0][ElectricFullLoadCurveReader.Fields.DrivingTorque]);
+			Assert.AreEqual("-401.07", fldLow.Rows[0][ElectricFullLoadCurveReader.Fields.GenerationTorque]);
+
+			var fldMapLow = ElectricFullLoadCurveReader.Create(fldLow, 1);
+			Assert.AreEqual(-401.07, fldMapLow.FullLoadDriveTorque(0.RPMtoRad()).Value());
+			Assert.AreEqual(401.07, fldMapLow.FullGenerationTorque(0.RPMtoRad()).Value());
+
+			var pwrLow = inputProvider.VoltageLevels.First().EfficiencyMap;
+			Assert.AreEqual("0", pwrLow.Rows[0][ElectricMotorMapReader.Fields.MotorSpeed]);
+			Assert.AreEqual("-800", pwrLow.Rows[0][ElectricMotorMapReader.Fields.Torque]);
+			Assert.AreEqual("9.8449", pwrLow.Rows[0][ElectricMotorMapReader.Fields.PowerElectrical]);
+
+			var pwrMapLow = ElectricMotorMapReader.Create(pwrLow, 1);
+			Assert.AreEqual(-10171.0, pwrMapLow.LookupElectricPower(-0.RPMtoRad(), -800.SI<NewtonMeter>()).ElectricalPower.Value());
+
+			Assert.AreEqual(-20430.186, pwrMapLow.LookupElectricPower(120.RPMtoRad(), -800.SI<NewtonMeter>()).ElectricalPower.Value(), 1e-3);
+
+
+
+			Assert.AreEqual(600, inputProvider.VoltageLevels[1].VoltageLevel.Value());
+
+			var fldHi = inputProvider.VoltageLevels.Last().FullLoadCurve;
+			Assert.AreEqual("0", fldHi.Rows[0][ElectricFullLoadCurveReader.Fields.MotorSpeed]);
+			Assert.AreEqual("476.284", fldHi.Rows[0][ElectricFullLoadCurveReader.Fields.DrivingTorque]);
+			Assert.AreEqual("-486.284", fldHi.Rows[0][ElectricFullLoadCurveReader.Fields.GenerationTorque]);
+
+			var fldMapHi = ElectricFullLoadCurveReader.Create(fldHi, 1);
+			Assert.AreEqual(-476.284, fldMapHi.FullLoadDriveTorque(0.RPMtoRad()).Value());
+			Assert.AreEqual(486.284, fldMapHi.FullGenerationTorque(0.RPMtoRad()).Value());
+
+			var pwrHi = inputProvider.VoltageLevels.Last().EfficiencyMap;
+			Assert.AreEqual("0", pwrHi.Rows[0][ElectricMotorMapReader.Fields.MotorSpeed]);
+			Assert.AreEqual("-800", pwrHi.Rows[0][ElectricMotorMapReader.Fields.Torque]);
+			Assert.AreEqual("8.86041", pwrHi.Rows[0][ElectricMotorMapReader.Fields.PowerElectrical]);
+
+			var pwrMap = ElectricMotorMapReader.Create(pwrHi, 1);
+			Assert.AreEqual(-9153.9, pwrMap.LookupElectricPower(-0.RPMtoRad(), -800.SI<NewtonMeter>()).ElectricalPower.Value());
+
+			Assert.AreEqual(-18387.16730, pwrMap.LookupElectricPower(120.RPMtoRad(), -800.SI<NewtonMeter>()).ElectricalPower.Value(), 1e-3);
+		}
+
+		[TestCase()]
+		public void TestElectricMotorV3_Lookup()
+		{
+			var inputProvider =
+				new JSONComponentInputData(@"TestData\Hybrids\ElectricMotor\GenericEMotorV3.vem", null,
+					false);
+			var daa = new EngineeringDataAdapter();
+			var emData = daa.CreateElectricMachines(inputProvider.ElectricMachines, null).First().Item2;
+
+			var em = emData.EfficiencyData;
+
+			Assert.AreEqual(-334.2300, em.FullLoadDriveTorque(400.SI<Volt>(), 2000.RPMtoRad()).Value());
+			Assert.AreEqual(-396.076, em.FullLoadDriveTorque(600.SI<Volt>(), 2000.RPMtoRad()).Value());
+			Assert.AreEqual(-365.153, em.FullLoadDriveTorque(500.SI<Volt>(), 2000.RPMtoRad()).Value());
+			Assert.AreEqual(-380.6145, em.FullLoadDriveTorque(550.SI<Volt>(), 2000.RPMtoRad()).Value());
+
+			Assert.AreEqual(334.2300, em.FullGenerationTorque(400.SI<Volt>(), 2000.RPMtoRad()).Value());
+			Assert.AreEqual(406.076, em.FullGenerationTorque(600.SI<Volt>(), 2000.RPMtoRad()).Value());
+			Assert.AreEqual(370.153, em.FullGenerationTorque(500.SI<Volt>(), 2000.RPMtoRad()).Value());
+			Assert.AreEqual(388.1145, em.FullGenerationTorque(550.SI<Volt>(), 2000.RPMtoRad()).Value());
+
+			Assert.AreEqual(26, em.LookupDragTorque(400.SI<Volt>(), 2000.RPMtoRad()).Value());
+			Assert.AreEqual(33, em.LookupDragTorque(600.SI<Volt>(), 2000.RPMtoRad()).Value());
+			Assert.AreEqual(29.5, em.LookupDragTorque(500.SI<Volt>(), 2000.RPMtoRad()).Value());
+			Assert.AreEqual(31.25, em.LookupDragTorque(550.SI<Volt>(), 2000.RPMtoRad()).Value());
+
+			Assert.AreEqual(-101.760, em.EfficiencyMapLookupTorque(400.SI<Volt>(), -25000.SI<Watt>(), 2000.RPMtoRad(), -300.SI<NewtonMeter>()).Value(), 1e-3);
+            Assert.AreEqual(-115.1818, em.EfficiencyMapLookupTorque(600.SI<Volt>(), -25000.SI<Watt>(), 2000.RPMtoRad(), -300.SI<NewtonMeter>()).Value(), 1e-3);
+            Assert.AreEqual(14.5383, em.EfficiencyMapLookupTorque(500.SI<Volt>(), -25000.SI<Watt>(), 2000.RPMtoRad(), -300.SI<NewtonMeter>()).Value(), 1e-3);
+            Assert.AreEqual(14.5383, em.EfficiencyMapLookupTorque(550.SI<Volt>(), -25000.SI<Watt>(), 2000.RPMtoRad(), -300.SI<NewtonMeter>()).Value(), 1e-3);
+
+		}
+
+
 		[TestCase()]
 		public void TestReadElectricMotorAggregation()
 		{

VectoCore/VectoCoreTest/Integration/Hybrid/ParallelHybridTest.cs

@@ -1182,7 +1182,7 @@ namespace TUGraz.VectoCore.Tests.Integration.Hybrid
 			TestCase(80, 0.5, -5, 0, TestName = "P4 Hybrid ConstantSpeed 80km/h SoC: 0.5, DH 5%"),
 
 			TestCase(30, 0.25, 0, 1000, TestName = "P4 Hybrid ConstantSpeed 30km/h SoC: 0.25, level P_auxEl: 1kW"),
-			TestCase(30, 0.25, 0, 5000, TestName = "P4 Hybrid ConstantSpeed 30km/h SoC: 0.25, level P_auxEl: 5kW"),
+			TestCase(30, 0.25, 0, 3000, TestName = "P4 Hybrid ConstantSpeed 30km/h SoC: 0.25, level P_auxEl: 3kW"),
 		]
 		public void P4HybridConstantSpeed(double vmax, double initialSoC, double slope, double pAuxEl)
 		{

VectoCore/VectoCoreTest/TestData/Hybrids/ElectricMotor/GenericDragHV.vemd

+n [rpm] , T_drag [Nm]
+0       , -15
+5000    , -60
\ No newline at end of file

VectoCore/VectoCoreTest/TestData/Hybrids/ElectricMotor/GenericEMotorHV.vemp

+n [rpm] , T_drive [Nm] , T_recuperation [Nm]
+0       , 476.284      , -486.284
+1600    , 476.284      , -486.284
+1665    , 476.284      , -486.284
+1675    , 473.896      , -483.896
+1685    , 471.052      , -481.052
+1695    , 468.244      , -478.244
+1700    , 466.852      , -476.852
+1750    , 453.364      , -463.364
+1800    , 440.632      , -450.632
+1850    , 428.584      , -438.584
+1900    , 417.184      , -427.184
+1950    , 406.36       , -416.36
+2000    , 396.076      , -406.076
+2050    , 386.284      , -396.284
+2100    , 376.972      , -386.972
+2150    , 368.092      , -378.092
+2200    , 359.608      , -369.608
+2250    , 351.508      , -361.508
+2300    , 343.756      , -353.756
+2350    , 336.34       , -346.34
+2400    , 329.224      , -339.224
+2450    , 322.408      , -332.408
+2500    , 315.856      , -325.856
+2550    , 309.568      , -319.568
+2600    , 303.52       , -313.52
+2650    , 297.7        , -307.7
+2700    , 292.084      , -302.084
+2750    , 286.684      , -296.684
+2800    , 281.476      , -291.476
+2850    , 276.448      , -286.448
+2900    , 271.6        , -281.6
+2950    , 266.908      , -276.908
+3000    , 262.384      , -272.384
+3050    , 257.992      , -267.992
+3100    , 253.756      , -263.756
+3150    , 249.652      , -259.652
+3200    , 245.668      , -255.668
+3250    , 241.816      , -251.816
+3300    , 238.072      , -248.072
+3350    , 234.448      , -244.448
+3400    , 230.92       , -240.92
+3450    , 227.5        , -237.5
+3500    , 224.188      , -234.188
+3550    , 220.96       , -230.96
+3600    , 217.816      , -227.816
+3650    , 214.768      , -224.768
+3700    , 211.792      , -221.792
+3750    , 208.9        , -218.9
+3800    , 206.092      , -216.092
+3850    , 203.344      , -213.344
+3900    , 200.68       , -210.68
+3950    , 198.076      , -208.076
+4000    , 195.532      , -205.532
+4050    , 193.06       , -203.06
+4100    , 190.648      , -200.648
+4150    , 188.284      , -198.284
+4200    , 185.98       , -195.98
+4250    , 183.736      , -193.736
+4300    , 181.54       , -191.54
+4350    , 179.404      , -189.404
+4400    , 177.304      , -187.304
+4450    , 175.252      , -185.252
+4500    , 173.248      , -183.248
+4550    , 171.292      , -181.292
+4600    , 169.384      , -179.384
+4650    , 167.5        , -177.5
+4700    , 165.664      , -175.664
+4750    , 163.876      , -173.876
+4800    , 162.112      , -172.112
+4850    , 160.384      , -170.384
+4900    , 158.704      , -168.704
+4950    , 157.048      , -167.048
+5000    , 155.428      , -165.428

VectoCore/VectoCoreTest/TestData/Hybrids/ElectricMotor/GenericEMotorV2.vem

+{
+  "Header": {
+    "CreatedBy": " ()",
+    "Date": "2016-10-13T08:54:28.7387223Z",
+    "AppVersion": "3",
+    "FileVersion": 2
+  },
+  "Body": {
+    "SavedInDeclMode": false,
+    "Model": "Generic Electric Motor",
+    "FullLoadCurve": "GenericEMotor.vemp",
+    "DragCurve": "GenericDrag.vemd",
+    "EfficiencyMap": "GenericMap.vemo",
+    "Inertia": 0.15,
+    "ContinuousTorque": 100,
+    "ContinuousTorqueSpeed": 2000,
+    "OverloadTorque":  300,
+    "OverloadTorqueSpeed": 2000, 
+    "OverloadTime": 10,
+    "ThermalOverloadRecoveryFactor": 0.9
+  }
+}
\ No newline at end of file

VectoCore/VectoCoreTest/TestData/Hybrids/ElectricMotor/GenericEMotorV3.vem

+{
+  "Header": {
+    "CreatedBy": "",
+    "Date": "2021-06-24T12:10:33.6353304Z",
+    "AppVersion": "3",
+    "FileVersion": 3
+  },
+  "Body": {
+    "SavedInDeclMode": false,
+    "Model": "Generic Electric Motor",
+    "Inertia": 0.15,
+    "ContinuousTorque": 100.0,
+    "ContinuousTorqueSpeed": 1999.9999999999998,
+    "OverloadTorque": 300.0,
+    "OverloadTorqueSpeed": 1999.9999999999998,
+    "OverloadTime": 10.0,
+    "ThermalOverloadRecoveryFactor": 0.9,
+    "VoltageLevels": [
+      {
+        "Voltage": 400.0,
+        "FullLoadCurve": "GenericEMotor.vemp",
+        "DragCurve": "GenericDrag.vemd",
+        "EfficiencyMap": "GenericMap.vemo"
+      },
+      {
+        "Voltage": 600.0,
+        "FullLoadCurve": "GenericEMotorHV.vemp",
+        "DragCurve": "GenericDragHV.vemd",
+        "EfficiencyMap": "GenericMapHV.vemo"
+      }
+    ]
+  }
+}
\ No newline at end of file

VectoCore/VectoCoreTest/VectoCoreTest.csproj

@@ -634,6 +634,12 @@
     <None Include="TestData\Hybrids\ElectricMotor\GenericDrag.vemd">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Include="TestData\Hybrids\ElectricMotor\GenericDragHV.vemd">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="TestData\Hybrids\ElectricMotor\GenericEMotorHV.vemp">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Include="TestData\Hybrids\ElectricMotor\GenericEMotorV2.vem">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
@@ -649,6 +655,9 @@
     <None Include="TestData\Hybrids\ElectricMotor\GenericEMotor240kW.vemp">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Include="TestData\Hybrids\ElectricMotor\GenericEMotorV3.vem">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Include="TestData\Hybrids\ElectricMotor\GenericMap.vemo">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
@@ -712,6 +721,9 @@
     <None Include="TestData\Hybrids\BusAuxEngineeringMode\MT_6_Bus.vgbx">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Include="TestData\Hybrids\ElectricMotor\GenericMapHV.vemo">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Include="TestData\Hybrids\GenericVehicle_Group2_P2\175kW.vfld">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>