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
Commit d36fdbb7 authored by Markus Quaritsch's avatar Markus Quaritsch
Browse files

Merge branch 'develop' of...

Merge branch 'develop' of https://webgate.ec.europa.eu/CITnet/stash/scm/~emquarima/vecto-sim into feature/VECTO-83-adapt-engine-only-simulation-for

Conflicts:
	VectoCoreTest/TestData/Results/EngineFullLoadJumps/EngineFLJ_1000rpm_1Hz.csv
	VectoCoreTest/VectoCoreTest.csproj
parents a6727fb6 6d9a59fa
No related branches found
No related tags found
No related merge requests found
Showing
with 2190 additions and 593 deletions
......@@ -169,7 +169,7 @@ namespace TUGraz.VectoCore.Models.Simulation.Data
[ModalResultField(typeof (double))] grad,
/// <summary>
/// [-] Gear. "0" = clutch opened / neutral. "0.5" = lock-up clutch is open (AT with torque converter only, see
/// [-] GearData. "0" = clutch opened / neutral. "0.5" = lock-up clutch is open (AT with torque converter only, see
/// Gearbox)
/// </summary>
[ModalResultField(typeof (double))] Gear,
......
......@@ -169,7 +169,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data
{
var curve = _fullLoadCurves.FirstOrDefault(kv => kv.Key.Contains(gear));
if (curve.Key.Equals(null)) {
throw new KeyNotFoundException(string.Format("Gear '{0}' was not found in the FullLoadCurves.", gear));
throw new KeyNotFoundException(string.Format("GearData '{0}' was not found in the FullLoadCurves.", gear));
}
return curve.Value;
......@@ -180,51 +180,8 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data
/// </summary>
public class Data
{
[JsonProperty(Required = Required.Always)] public JsonDataHeader Header;
[JsonProperty(Required = Required.Always)] public DataBody Body;
[JsonProperty(Required = Required.Always)] public DataHeader Header;
public class DataHeader
{
[JsonProperty(Required = Required.Always)] public string AppVersion;
[JsonProperty(Required = Required.Always)] public string CreatedBy;
[JsonProperty(Required = Required.Always)] public DateTime Date;
[JsonProperty(Required = Required.Always)] public double FileVersion;
#region Equality members
protected bool Equals(DataHeader other)
{
return string.Equals(CreatedBy, other.CreatedBy) && Date.Equals(other.Date) &&
string.Equals(AppVersion, other.AppVersion) && FileVersion.Equals(other.FileVersion);
}
public override bool Equals(object obj)
{
if (ReferenceEquals(null, obj)) {
return false;
}
if (ReferenceEquals(this, obj)) {
return true;
}
if (obj.GetType() != GetType()) {
return false;
}
return Equals((DataHeader) obj);
}
public override int GetHashCode()
{
unchecked {
var hashCode = (CreatedBy != null ? CreatedBy.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ Date.GetHashCode();
hashCode = (hashCode * 397) ^ (AppVersion != null ? AppVersion.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ FileVersion.GetHashCode();
return hashCode;
}
}
#endregion
}
public class DataBody
{
......@@ -278,7 +235,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data
/// <summary>
/// Multiple Full Load and Drag Curves (.vfld) can be defined and assigned to different gears.
/// Gear "0" must be assigned for idling and Engine Only Mode.
/// GearData "0" must be assigned for idling and Engine Only Mode.
/// </summary>
public class DataFullLoadCurve
{
......
......@@ -103,7 +103,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data
public const string EngineSpeed = "n";
/// <summary>
/// [-] Gear input. Overwrites the gear shift model.
/// [-] GearData input. Overwrites the gear shift model.
/// </summary>
public const string Gear = "gear";
......@@ -181,7 +181,7 @@ namespace TUGraz.VectoCore.Models.SimulationComponent.Data
public PerSecond EngineSpeed { get; set; }
/// <summary>
/// [-] Gear input. Overwrites the gear shift model.
/// [-] GearData input. Overwrites the gear shift model.
/// </summary>
public double Gear { get; set; }
......
namespace TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox
{
public class GearData
{
public ShiftPolygon ShiftPolygon { get; protected set; }
public TransmissionLossMap LossMap { get; protected set; }
public double Ratio { get; protected set; }
public bool TorqueConverterActive { get; protected set; } // TODO: think about refactoring...
public double AverageEfficiency { get; set; }
public GearData(TransmissionLossMap lossMap, Gearbox.ShiftPolygon shiftPolygon, double ratio,
bool torqueconverterActive)
{
LossMap = lossMap;
ShiftPolygon = shiftPolygon;
Ratio = ratio;
TorqueConverterActive = torqueconverterActive;
}
}
}
\ No newline at end of file
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Runtime.Remoting.Messaging;
using Common.Logging;
using TUGraz.VectoCore.Exceptions;
using TUGraz.VectoCore.Utils;
namespace TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox
{
public class ShiftPolygon : SimulationComponentData
{
private List<ShiftPolygonEntry> _entries;
public static ShiftPolygon ReadFromFile(string fileName)
{
var data = VectoCSVFile.Read(fileName);
if (data.Columns.Count != 3) {
throw new VectoException("ShiftPolygon Data File must contain 3 columns.");
}
if (data.Rows.Count < 2) {
throw new VectoException("ShiftPolygon must consist of at least tow lines with numeric values (below file header)");
}
List<ShiftPolygonEntry> entries;
if (HeaderIsValid(data.Columns)) {
entries = CreateFromColumnNames(data);
} else {
var log = LogManager.GetLogger<ShiftPolygon>();
log.WarnFormat(
"ShiftPolygon: Header Line is not valid. Expected: '{0}, {1}, {2}', Got: '{3}'. Falling back to column index",
Fields.Torque, Fields.AngularSpeedUp, Fields.AngluarSpeedDown,
string.Join(", ", data.Columns.Cast<DataColumn>().Select(c => c.ColumnName).Reverse()));
entries = CreateFromColumnIndizes(data);
}
return new ShiftPolygon { _entries = entries };
}
public ShiftPolygonEntry this[int i]
{
get { return _entries[i]; }
}
private static bool HeaderIsValid(DataColumnCollection columns)
{
return columns.Contains(Fields.Torque) && columns.Contains(Fields.AngularSpeedUp) &&
columns.Contains((Fields.AngluarSpeedDown));
}
private static List<ShiftPolygonEntry> CreateFromColumnNames(DataTable data)
{
return (from DataRow row in data.Rows
select new ShiftPolygonEntry {
Torque = row.ParseDouble(Fields.Torque).SI<NewtonMeter>(),
AngularSpeedDown = row.ParseDouble(Fields.AngluarSpeedDown).RPMtoRad(),
AngularSpeedUp = row.ParseDouble(Fields.AngularSpeedUp).RPMtoRad()
}).ToList();
}
private static List<ShiftPolygonEntry> CreateFromColumnIndizes(DataTable data)
{
return (from DataRow row in data.Rows
select
new ShiftPolygonEntry {
Torque = row.ParseDouble(0).SI<NewtonMeter>(),
AngularSpeedDown = row.ParseDouble(1).RPMtoRad(),
AngularSpeedUp = row.ParseDouble(2).RPMtoRad()
}).ToList();
}
private static class Fields
{
/// <summary>
/// [Nm] torque
/// </summary>
public const string Torque = "engine torque";
/// <summary>
/// [rpm] threshold for upshift
/// </summary>
public const string AngularSpeedUp = "upshift rpm";
/// <summary>
/// [rpm] threshold for downshift
/// </summary>
public const string AngluarSpeedDown = "downshift rpm";
}
public class ShiftPolygonEntry
{
/// <summary>
/// [Nm] engine torque
/// </summary>
public NewtonMeter Torque { get; set; }
/// <summary>
/// [1/s] angular velocity threshold for downshift
/// </summary>
public PerSecond AngularSpeedDown { get; set; }
/// <summary>
/// [1/s] angular velocity threshold for upshift
/// </summary>
public PerSecond AngularSpeedUp { get; set; }
}
}
}
\ No newline at end of file
namespace TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox
{
public class TorqueConverterData {}
}
\ No newline at end of file
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Runtime.InteropServices;
using System.Runtime.Remoting.Messaging;
using Common.Logging;
using Newtonsoft.Json;
using TUGraz.VectoCore.Exceptions;
using TUGraz.VectoCore.Utils;
namespace TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox
{
public class TransmissionLossMap
{
[JsonProperty] private readonly List<GearLossMapEntry> _entries;
private readonly DelauneyMap _lossMap; // Input Speed, Output Torque (to Wheels) => Input Torque (Engine)
//private readonly DelauneyMap _reverseLossMap; // Input Speed, Input Torque (Engine) => Output Torque (Wheels)
public static TransmissionLossMap ReadFromFile(string fileName, double gearRatio)
{
var data = VectoCSVFile.Read(fileName, true);
if (data.Columns.Count < 3) {
throw new VectoException("TransmissionLossMap Data File must consist of at least 3 columns.");
}
if (data.Rows.Count < 4) {
throw new VectoException(
"TransmissionLossMap must consist of at least four lines with numeric values (below file header");
}
List<GearLossMapEntry> entries;
if (HeaderIsValid(data.Columns)) {
entries = CreateFromColumnNames(data);
} else {
var log = LogManager.GetLogger<TransmissionLossMap>();
log.WarnFormat(
"TransmissionLossMap: Header line is not valid. Expected: '{0}, {1}, {2}, <{3}>'. Got: '{4}'. Falling back to column index.",
Fields.InputSpeed, Fields.InputTorque, Fields.TorqeLoss, Fields.Efficiency,
string.Join(", ", data.Columns.Cast<DataColumn>().Select(c => c.ColumnName).Reverse()));
entries = CreateFromColumIndizes(data);
}
return new TransmissionLossMap(entries, gearRatio);
}
private static bool HeaderIsValid(DataColumnCollection columns)
{
return columns.Contains(Fields.InputSpeed) && columns.Contains(Fields.InputTorque) &&
columns.Contains(Fields.TorqeLoss);
}
private static List<GearLossMapEntry> CreateFromColumnNames(DataTable data)
{
var hasEfficiency = data.Columns.Contains(Fields.Efficiency);
return (from DataRow row in data.Rows
select new GearLossMapEntry {
InputSpeed = row.ParseDouble(Fields.InputSpeed).RPMtoRad(),
InputTorque = row.ParseDouble(Fields.InputTorque).SI<NewtonMeter>(),
TorqueLoss = row.ParseDouble(Fields.TorqeLoss).SI<NewtonMeter>(),
Efficiency =
(!hasEfficiency || row[Fields.Efficiency] == DBNull.Value || row[Fields.Efficiency] != null)
? Double.NaN
: row.ParseDouble(Fields.Efficiency)
}).ToList();
}
private static List<GearLossMapEntry> CreateFromColumIndizes(DataTable data)
{
var hasEfficiency = (data.Columns.Count >= 4);
return (from DataRow row in data.Rows
select new GearLossMapEntry {
InputSpeed = row.ParseDouble(0).RPMtoRad(),
InputTorque = row.ParseDouble(1).SI<NewtonMeter>(),
TorqueLoss = row.ParseDouble(2).SI<NewtonMeter>(),
Efficiency = (!hasEfficiency || row[3] == DBNull.Value || row[3] != null) ? double.NaN : row.ParseDouble(3)
}).ToList();
}
private TransmissionLossMap(List<GearLossMapEntry> entries, double gearRatio)
{
_entries = entries;
_lossMap = new DelauneyMap();
//_reverseLossMap = new DelauneyMap();
foreach (var entry in _entries) {
_lossMap.AddPoint(entry.InputSpeed.Double(), (entry.InputTorque.Double() - entry.TorqueLoss.Double()) * gearRatio,
entry.InputTorque.Double());
// @@@quam: according to Raphael, not needed for now...
//_reverseLossMap.AddPoint(entry.InputSpeed.Double(), entry.InputTorque.Double(),
// entry.InputTorque.Double() - entry.TorqueLoss.Double());
}
_lossMap.Triangulate();
//_reverseLossMap.Triangulate();
}
/// <summary>
/// Compute the required torque at the input of the gear(box) (from engine)
/// </summary>
/// <param name="angularVelocity">[1/s] angular speed of the shaft</param>
/// <param name="gbxOutTorque">[Nm] torque requested by the previous componend (towards the wheels)</param>
/// <returns>[Nm] torque requested from the next component (towards the engine)</returns>
public NewtonMeter GearboxInTorque(PerSecond angularVelocity, NewtonMeter gbxOutTorque)
{
try {
return VectoMath.Max(_lossMap.Interpolate(angularVelocity.Double(), gbxOutTorque.Double()).SI<NewtonMeter>(),
0.SI<NewtonMeter>());
} catch (Exception e) {
throw new VectoSimulationException(
String.Format("Failed to interpolate in TransmissionLossMap. angularVelocity: {0}, torque: {1}", angularVelocity,
gbxOutTorque), e);
}
}
/// <summary>
/// Compute the available torque at the output of the gear(box) (towards wheels)
/// </summary>
/// <param name="angularVelocity">[1/s] angular speed of the shaft</param>
/// <param name="gbxInTorque">[Nm] torque provided by the engine at the gearbox' input shaft</param>
/// <returns>[Nm] torque provided to the next component (towards the wheels)</returns>
//public NewtonMeter GearboxOutTorque(PerSecond angularVelocity, NewtonMeter gbxInTorque)
//{
// // TODO extrapolate!
// return _reverseLossMap.Interpolate(angularVelocity.Double(), gbxInTorque.Double()).SI<NewtonMeter>();
//}
public GearLossMapEntry this[int i]
{
get { return _entries[i]; }
}
public class GearLossMapEntry
{
public PerSecond InputSpeed { get; set; }
public NewtonMeter InputTorque { get; set; }
public NewtonMeter TorqueLoss { get; set; }
public double Efficiency { get; set; }
}
private static class Fields
{
/// <summary>
/// [rpm]
/// </summary>
public const string InputSpeed = "Input Speed";
/// <summary>
/// [Nm]
/// </summary>
public const string InputTorque = "Input Torque";
/// <summary>
/// [Nm]
/// </summary>
public const string TorqeLoss = "Torque Loss";
/// <summary>
/// [-]
/// </summary>
public const string Efficiency = "Eff";
}
}
}
\ No newline at end of file
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.Models.SimulationComponent.Data.Gearbox;
using TUGraz.VectoCore.Utils;
namespace TUGraz.VectoCore.Models.SimulationComponent.Data
{
/// <summary>
/// Represents the Data containing all parameters of the gearbox
/// </summary>
/// {
/// "Header": {
/// "CreatedBy": "Raphael Luz IVT TU-Graz (85407225-fc3f-48a8-acda-c84a05df6837)",
/// "Date": "29.07.2014 16:59:17",
/// "AppVersion": "2.0.4-beta",
/// "FileVersion": 4
/// },
/// "Body": {
/// "SavedInDeclMode": false,
/// "ModelName": "Generic 24t Coach",
/// "Inertia": 0.0,
/// "TracInt": 1.0,
/// "TqReserve": 20.0,
/// "SkipGears": true,
/// "ShiftTime": 2,
/// "EaryShiftUp": true,
/// "StartTqReserve": 20.0,
/// "StartSpeed": 2.0,
/// "StartAcc": 0.6,
/// "GearboxType": "AMT",
/// "TorqueConverter": {
/// "Enabled": false,
/// "File": "<NOFILE>",
/// "RefRPM": 0.0,
/// "Inertia": 0.0
/// }
/// "Gears": [
/// {
/// "Ratio": 3.240355,
/// "LossMap": "Axle.vtlm"
/// },
/// {
/// "Ratio": 6.38,
/// "LossMap": "Indirect GearData.vtlm",
/// "TCactive": false,
/// "ShiftPolygon": "ShiftPolygon.vgbs"
/// },
/// ...
/// ]
/// }
[DataContract]
public class GearboxData : SimulationComponentData
{
public enum GearboxType
{
ManualTransmision,
AutomatedManualTransmission,
AutomaticTransmission,
Custom
}
[DataMember]
public GearData AxleGearData { get; protected set; }
//private double _axleGearEfficiency;
[DataMember] private Dictionary<uint, GearData> _gearData = new Dictionary<uint, GearData>();
//private Dictionary<uint, double> _gearEfficiency = new Dictionary<uint, double>();
[DataMember] private Data _data;
[DataMember] private GearboxType _type;
public static GearboxData ReadFromFile(string fileName)
{
return ReadFromJson(File.ReadAllText(fileName), Path.GetDirectoryName(fileName));
}
public static GearboxData ReadFromJson(string json, string basePath = "")
{
// var lossMaps = new Dictionary<string, TransmissionLossMap>();
var gearboxData = new GearboxData();
var d = JsonConvert.DeserializeObject<Data>(json);
if (d.Header.FileVersion > 4) {
throw new UnsupportedFileVersionException("Unsupported Version of .vgbx file. Got Version: " + d.Header.FileVersion);
}
gearboxData._data = d;
for (uint i = 0; i < d.Body.Gears.Count; i++) {
var gearSettings = d.Body.Gears[(int) i];
var lossMapPath = Path.Combine(basePath, gearSettings.LossMap);
TransmissionLossMap lossMap = TransmissionLossMap.ReadFromFile(lossMapPath, gearSettings.Ratio);
var shiftPolygon = !String.IsNullOrEmpty(gearSettings.ShiftPolygon)
? ShiftPolygon.ReadFromFile(Path.Combine(basePath, gearSettings.ShiftPolygon))
: null;
var gear = new GearData(lossMap, shiftPolygon, gearSettings.Ratio, gearSettings.TCactive);
if (i == 0) {
gearboxData.AxleGearData = gear;
} else {
gearboxData._gearData.Add(i, gear);
}
}
switch (d.Body.GearboxTypeStr) {
case "AMT":
gearboxData._type = GearboxType.AutomatedManualTransmission;
break;
case "MT":
gearboxData._type = GearboxType.ManualTransmision;
break;
case "AT":
gearboxData._type = GearboxType.AutomaticTransmission;
break;
default:
gearboxData._type = GearboxType.Custom;
break;
}
return gearboxData;
}
// @@@quam: according to Raphael no longer required
//public void CalculateAverageEfficiency(CombustionEngineData engineData)
//{
// var angularVelocityStep = (2.0 / 3.0) * (engineData.GetFullLoadCurve(0).RatedSpeed() - engineData.IdleSpeed) / 10.0;
// var axleGearEfficiencySum = 0.0;
// var axleGearSumCount = 0;
// foreach (var gearEntry in _gearData) {
// var gearEfficiencySum = 0.0;
// var gearSumCount = 0;
// for (var angularVelocity = engineData.IdleSpeed + angularVelocityStep;
// angularVelocity < engineData.GetFullLoadCurve(0).RatedSpeed();
// angularVelocity += angularVelocityStep) {
// var fullLoadStationaryTorque = engineData.GetFullLoadCurve(gearEntry.Key).FullLoadStationaryTorque(angularVelocity);
// var torqueStep = (2.0 / 3.0) * fullLoadStationaryTorque / 10.0;
// for (var engineOutTorque = (1.0 / 3.0) * fullLoadStationaryTorque;
// engineOutTorque < fullLoadStationaryTorque;
// engineOutTorque += torqueStep) {
// var engineOutPower = Formulas.TorqueToPower(engineOutTorque, angularVelocity);
// var gearboxOutPower =
// Formulas.TorqueToPower(
// gearEntry.Value.LossMap.GearboxOutTorque(angularVelocity, engineOutTorque), angularVelocity);
// if (gearboxOutPower > engineOutPower) {
// gearboxOutPower = engineOutPower;
// }
// gearEfficiencySum += ((engineOutPower - gearboxOutPower) / engineOutPower).Double();
// gearSumCount += 1;
// // axle gear
// var angularVelocityAxleGear = angularVelocity / gearEntry.Value.Ratio;
// var axlegearOutPower =
// Formulas.TorqueToPower(
// AxleGearData.LossMap.GearboxOutTorque(angularVelocityAxleGear,
// Formulas.PowerToTorque(engineOutPower, angularVelocityAxleGear)),
// angularVelocityAxleGear);
// if (axlegearOutPower > engineOutPower) {
// axlegearOutPower = engineOutPower;
// }
// axleGearEfficiencySum += (axlegearOutPower / engineOutPower).Double();
// axleGearSumCount += 1;
// }
// }
// gearEntry.Value.AverageEfficiency = gearEfficiencySum / gearSumCount;
// }
// AxleGearData.AverageEfficiency = axleGearEfficiencySum / axleGearSumCount;
//}
public int GearsCount()
{
return _data.Body.Gears.Count;
}
public GearData this[uint i]
{
get { return _gearData[i]; }
}
public bool SavedInDeclarationMode
{
get { return _data.Body.SavedInDeclarationMode; }
protected set { _data.Body.SavedInDeclarationMode = value; }
}
public GearboxType Type()
{
return _type;
}
/// <summary>
/// kgm^2
/// </summary>
public SI Inertia
{
get { return _data.Body.Inertia.SI().Kilo.Gramm.Square.Meter; }
protected set { _data.Body.Inertia = (double) value.ConvertTo().Kilo.Gramm.Square.Meter; }
}
/// <summary>
/// [s]
/// </summary>
public Second TractionInterruption
{
get { return _data.Body.TractionInterruption.SI<Second>(); }
protected set { _data.Body.TractionInterruption = value.Double(); }
}
public double TorqueReserve
{
get { return _data.Body.TorqueReserve / 100; }
protected set { _data.Body.TorqueReserve = value * 100; }
}
/// <summary>
/// used by gear-shift model
/// </summary>
public bool SkipGears
{
get { return _data.Body.SkipGears; }
protected set { _data.Body.SkipGears = value; }
}
public Second ShiftTime
{
get { return _data.Body.ShiftTime.SI<Second>(); }
protected set { _data.Body.ShiftTime = value.Double(); }
}
public bool EarlyShiftUp
{
get { return _data.Body.EarlyShiftUp; }
protected set { _data.Body.EarlyShiftUp = value; }
}
public double StartTorqueReserve
{
get { return _data.Body.StartTorqueReserve / 100; }
protected set { _data.Body.StartTorqueReserve = value * 100; }
}
public MeterPerSecond StartSpeed
{
get { return _data.Body.StartSpeed.SI<MeterPerSecond>(); }
protected set { _data.Body.StartSpeed = value.Double(); }
}
public SI StartAcceleration
{
get { return _data.Body.StartAcceleration; }
protected set { _data.Body.StartAcceleration = value; }
}
/// <summary>
/// A class which represents the json data format for serializing and deseralizing the GearboxData files
/// </summary>
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;
/// <summary>
/// Model. Free text defining the gearbox model, type, etc.
/// </summary>
[JsonProperty(Required = Required.Always)] public string ModelName;
/// <summary>
/// [kgm^2] Rotation inertia of the gearbox (constant for all gears)
/// </summary>
[JsonProperty(Required = Required.Always)] public double Inertia;
/// <summary>
/// [s] Interruption during gear shift event
/// </summary>
[JsonProperty("TracInt", Required = Required.Always)] public double TractionInterruption;
/// <summary>
/// [%] This parameter is required for the "Allow shift-up inside polygons" and "Skip Gears" option
/// </summary>
[JsonProperty("TqReserve")] public double TorqueReserve;
[JsonProperty] public bool SkipGears;
/// <summary>
/// min. time interval between two gearshifts
/// </summary>
[JsonProperty] public double ShiftTime;
/// <summary>
/// ???
/// </summary>
[JsonProperty] public bool EarlyShiftUp;
/// <summary>
/// ???
/// </summary>
[JsonProperty("StartTqReserve")] public double StartTorqueReserve;
/// <summary>
/// [m/s] vehicle speed at start
/// </summary>
[JsonProperty] public double StartSpeed;
/// <summary>
/// [m/s^2] accelleration of the vehicle at start
/// </summary>
[JsonProperty("StartAcc")] public SI StartAcceleration;
[JsonProperty("GearboxType", Required = Required.Always)] public string GearboxTypeStr;
/// <summary>
/// Contains all parameters of the torque converter if used
/// </summary>
[JsonProperty] public TorqueConverterData TorqueConverter;
[JsonProperty(Required = Required.Always)] public IList<GearData> Gears;
public class GearData
{
[JsonProperty(Required = Required.Always)] public double Ratio;
[JsonProperty(Required = Required.Always)] public string LossMap;
[JsonProperty] public string ShiftPolygon;
[JsonProperty] public bool TCactive;
}
}
}
}
}
\ No newline at end of file
using System;
using Newtonsoft.Json;
namespace TUGraz.VectoCore.Models.SimulationComponent.Data
{
public class JsonDataHeader
{
[JsonProperty(Required = Required.Always)] public string AppVersion;
[JsonProperty(Required = Required.Always)] public string CreatedBy;
[JsonProperty(Required = Required.Always)] public DateTime Date;
[JsonProperty(Required = Required.Always)] public double FileVersion;
#region Equality members
protected bool Equals(JsonDataHeader other)
{
return string.Equals(CreatedBy, other.CreatedBy) && Date.Equals(other.Date) &&
string.Equals(AppVersion, other.AppVersion) && FileVersion.Equals(other.FileVersion);
}
public override bool Equals(object obj)
{
if (ReferenceEquals(null, obj)) {
return false;
}
if (ReferenceEquals(this, obj)) {
return true;
}
if (obj.GetType() != GetType()) {
return false;
}
return Equals((JsonDataHeader) obj);
}
public override int GetHashCode()
{
unchecked {
var hashCode = (CreatedBy != null ? CreatedBy.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ Date.GetHashCode();
hashCode = (hashCode * 397) ^ (AppVersion != null ? AppVersion.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ FileVersion.GetHashCode();
return hashCode;
}
}
#endregion
}
}
\ No newline at end of file
using System;
using TUGraz.VectoCore.Models.Connector.Ports;
using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
using TUGraz.VectoCore.Utils;
namespace TUGraz.VectoCore.Models.SimulationComponent.Impl
{
public class AxleGear : IPowerTrainComponent, ITnInPort, ITnOutPort
{
private ITnOutPort _nextComponent;
private readonly GearData _gearData;
public AxleGear(GearData gearData)
{
_gearData = gearData;
}
public ITnInPort InShaft()
{
return this;
}
public ITnOutPort OutShaft()
{
return this;
}
public void Connect(ITnOutPort other)
{
_nextComponent = other;
}
public IResponse Request(TimeSpan absTime, TimeSpan dt, NewtonMeter torque, PerSecond angularVelocity)
{
return _nextComponent.Request(absTime, dt,
_gearData.LossMap.GearboxInTorque(angularVelocity * _gearData.Ratio, torque),
angularVelocity * _gearData.Ratio);
}
}
}
\ No newline at end of file
......@@ -122,6 +122,12 @@ namespace TUGraz.VectoCore.Utils
return si + d;
}
public static T operator -(SIBase<T> si1)
{
return 0 - si1;
}
public static T operator -(SIBase<T> si1, SIBase<T> si2)
{
return (si1 as SI) - si2;
......@@ -129,7 +135,7 @@ namespace TUGraz.VectoCore.Utils
public static T operator -(SIBase<T> si1, SI si2)
{
return -si2 + si1;
return si1 - si2;
}
public static T operator -(SI si1, SIBase<T> si2)
......@@ -622,11 +628,6 @@ namespace TUGraz.VectoCore.Utils
return new SI(d - si1.Val, si1);
}
public static SI operator -(SI si1)
{
return 0 - si1;
}
public static SI operator *(SI si1, double d)
{
return new SI(si1.Val * d, si1);
......
......@@ -36,7 +36,7 @@ namespace TUGraz.VectoCore.Utils
/// <param name="fileName"></param>
/// <exception cref="FileIOException"></exception>
/// <returns>A DataTable which represents the CSV File.</returns>
public static DataTable Read(string fileName)
public static DataTable Read(string fileName, bool ignoreEmptyColumns = false)
{
try {
var lines = File.ReadAllLines(fileName);
......@@ -63,7 +63,7 @@ namespace TUGraz.VectoCore.Utils
var line = lines[i];
var cells = line.Split(Separator);
if (cells.Length != table.Columns.Count) {
if (!ignoreEmptyColumns && cells.Length != table.Columns.Count) {
throw new CSVReadException(string.Format("Line {0}: The number of values is not correct.", i));
}
......
......@@ -122,10 +122,17 @@
<Compile Include="Models\SimulationComponent\Data\DrivingCycleData.cs" />
<Compile Include="Models\SimulationComponent\Data\Engine\FuelConsumptionMap.cs" />
<Compile Include="Models\SimulationComponent\Data\Engine\FullLoadCurve.cs" />
<Compile Include="Models\SimulationComponent\Data\GearboxData.cs" />
<Compile Include="Models\SimulationComponent\Data\Gearbox\GearData.cs" />
<Compile Include="Models\SimulationComponent\Data\Gearbox\TransmissionLossMap.cs" />
<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\RetarderLossMap.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\IPowerTrainComponent.cs" />
......
using System;
using System.Globalization;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using TUGraz.VectoCore.Models.Simulation.Impl;
using TUGraz.VectoCore.Models.SimulationComponent.Data;
using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
using TUGraz.VectoCore.Models.SimulationComponent.Impl;
using TUGraz.VectoCore.Utils;
namespace TUGraz.VectoCore.Tests.Models.SimulationComponent
{
[TestClass]
public class GearboxTest
{
protected string GearboxDataFile = @"TestData\Components\24t Coach.vgbx";
public TestContext TestContext { get; set; }
[TestMethod]
public void AxleGearTest()
{
VehicleContainer vehicle = new VehicleContainer();
var gbxData = GearboxData.ReadFromFile(GearboxDataFile);
//GearData gearData = new GearData();
var axleGear = new AxleGear(gbxData.AxleGearData);
var mockPort = new MockTnOutPort();
axleGear.InShaft().Connect(mockPort);
var absTime = TimeSpan.FromSeconds(0);
var dt = TimeSpan.FromSeconds(1);
var rdyn = 520;
var speed = 20.320;
var angSpeed = SpeedToAngularSpeed(speed, rdyn);
var PvD = 279698.4.SI<Watt>();
// Double.Parse(TestContext.DataRow["PowerGbxOut"].ToString(), CultureInfo.InvariantCulture).SI<Watt>();
var torqueToWheels = Formulas.PowerToTorque(PvD, angSpeed);
//var torqueFromEngine = 0.SI<NewtonMeter>();
axleGear.Request(absTime, dt, torqueToWheels, angSpeed);
var loss = 9401.44062.SI<Watt>();
Assert.AreEqual(Formulas.PowerToTorque(PvD + loss, angSpeed * gbxData.AxleGearData.Ratio).Double(),
mockPort.Torque.Double(), 0.01,
"Torque Engine Side")
;
Assert.AreEqual((angSpeed * gbxData.AxleGearData.Ratio).Double(), mockPort.AngularVelocity.Double(), 0.01,
"Torque Engine Side");
}
protected PerSecond SpeedToAngularSpeed(double v, double r)
{
return ((60 * v) / (2 * r * Math.PI / 1000)).RPMtoRad();
}
}
}
\ No newline at end of file
using System;
using System.Globalization;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using TUGraz.VectoCore.Exceptions;
using TUGraz.VectoCore.Models.SimulationComponent.Data;
using TUGraz.VectoCore.Utils;
namespace TUGraz.VectoCore.Tests.Models.SimulationComponentData
{
[TestClass]
public class GearboxDataTest
{
public TestContext TestContext { get; set; }
protected const string GearboxFile = @"Testdata\Components\24t Coach.vgbx";
[TestMethod]
public void TestGearboxDataReadTest()
{
var gbxData = GearboxData.ReadFromFile(GearboxFile);
Assert.AreEqual(GearboxData.GearboxType.AutomatedManualTransmission, gbxData.Type());
Assert.AreEqual(1.0, gbxData.TractionInterruption.Double(), 0.0001);
Assert.AreEqual(9, gbxData.GearsCount());
Assert.AreEqual(3.240355, gbxData.AxleGearData.Ratio, 0.0001);
Assert.AreEqual(1.0, gbxData[7].Ratio, 0.0001);
Assert.AreEqual(-400, gbxData[1].ShiftPolygon[0].Torque.Double(), 0.0001);
Assert.AreEqual(560.RPMtoRad().Double(), gbxData[1].ShiftPolygon[0].AngularSpeedDown.Double(), 0.0001);
Assert.AreEqual(1289.RPMtoRad().Double(), gbxData[1].ShiftPolygon[0].AngularSpeedUp.Double(), 0.0001);
Assert.AreEqual(200.RPMtoRad().Double(), gbxData[1].LossMap[15].InputSpeed.Double(), 0.0001);
Assert.AreEqual(-350, gbxData[1].LossMap[15].InputTorque.Double(), 0.0001);
Assert.AreEqual(13.072, gbxData[1].LossMap[15].TorqueLoss.Double(), 0.0001);
}
[TestMethod]
[DataSource("Microsoft.VisualStudio.TestTools.DataSource.CSV",
"|DataDirectory|\\TestData\\AxleGearLossInterpolation.csv",
"AxleGearLossInterpolation#csv", DataAccessMethod.Sequential)]
public void TestInterpolation()
{
var rdyn = Double.Parse(TestContext.DataRow["rDyn"].ToString());
var speed = double.Parse(TestContext.DataRow["v"].ToString(), CultureInfo.InvariantCulture);
var gbxData = GearboxData.ReadFromFile(TestContext.DataRow["GearboxDataFile"].ToString());
var angSpeed = SpeedToAngularSpeed(speed, rdyn) * gbxData.AxleGearData.Ratio;
var PvD = Double.Parse(TestContext.DataRow["PowerGbxOut"].ToString(), CultureInfo.InvariantCulture).SI<Watt>();
var torqueToWheels = Formulas.PowerToTorque(PvD, angSpeed);
var torqueFromEngine = 0.SI<NewtonMeter>();
if (TestContext.DataRow["Gear"].ToString() == "A") {
torqueFromEngine = gbxData.AxleGearData.LossMap.GearboxInTorque(angSpeed, torqueToWheels);
}
var powerEngine = Formulas.TorqueToPower(torqueFromEngine, angSpeed);
var loss = powerEngine - PvD;
Assert.AreEqual(Double.Parse(TestContext.DataRow["GbxPowerLoss"].ToString(), CultureInfo.InvariantCulture),
loss.Double(), 0.1,
TestContext.DataRow["TestName"].ToString());
}
[TestMethod]
public void TestInputOutOfRange()
{
var rdyn = 520.0;
//var speed = double.Parse(TestContext.DataRow["v"].ToString(), CultureInfo.InvariantCulture);
var gbxData = GearboxData.ReadFromFile(GearboxFile);
var angSpeed = 2700.RPMtoRad();
var torqueToWheels = 100.SI<NewtonMeter>();
try {
gbxData.AxleGearData.LossMap.GearboxInTorque(angSpeed, torqueToWheels);
Assert.Fail("angular Speed too high");
} catch (Exception e) {
Assert.IsInstanceOfType(e, typeof (VectoSimulationException));
}
angSpeed = 1000.RPMtoRad();
torqueToWheels = 50000.SI<NewtonMeter>();
try {
gbxData.AxleGearData.LossMap.GearboxInTorque(angSpeed, torqueToWheels);
Assert.Fail("torque too high");
} catch (Exception e) {
Assert.IsInstanceOfType(e, typeof (VectoSimulationException));
}
angSpeed = 1000.RPMtoRad();
torqueToWheels = -5000.SI<NewtonMeter>();
try {
gbxData.AxleGearData.LossMap.GearboxInTorque(angSpeed, torqueToWheels);
Assert.Fail("torque too low");
} catch (Exception e) {
Assert.IsInstanceOfType(e, typeof (VectoSimulationException));
}
angSpeed = -1000.RPMtoRad();
torqueToWheels = 500.SI<NewtonMeter>();
try {
gbxData.AxleGearData.LossMap.GearboxInTorque(angSpeed, torqueToWheels);
Assert.Fail("negative angular speed");
} catch (Exception e) {
Assert.IsInstanceOfType(e, typeof (VectoSimulationException));
}
}
protected PerSecond SpeedToAngularSpeed(double v, double r)
{
return ((60 * v) / (2 * r * Math.PI / 1000)).RPMtoRad();
}
}
}
\ No newline at end of file
TestName,GearboxDataFile,rDyn,v,Gear,PowerGbxOut,GbxPowerLoss
Test1,TestData\Components\24t Coach.vgbx,"520","20.320",A,"279698.4","9401.44062"
Test2,TestData\Components\24t Coach.vgbx,"520","0.5858335",A,"17173.5","409.773677587509"
Test3,TestData\Components\24t Coach.vgbx,"520","0.3996113",A,"292.5253","118.282541632652"
Test4,TestData\Components\24t Coach.vgbx,"520","5.327739",A,"57431.12","2222.78785705566"
Test5,TestData\Components\24t Coach.vgbx,"520","5.661779",A,"73563.93","2553.00283432007"
Test6,TestData\Components\24t Coach.vgbx,"520","14.15156",A,"212829.5","6822.16882705688"
Test7,TestData\Components\24t Coach.vgbx,"520","14.55574",A,"15225.52","4308.41207504272"
Test8,TestData\Components\24t Coach.vgbx,"520","4.601774",A,"-1240.225","1362.09738254547"
Test9,TestData\Components\24t Coach.vgbx,"520","3.934339",A,"-698.5989","1164.5405292511"
\ No newline at end of file
{
"Header": {
"CreatedBy": "Raphael Luz IVT TU-Graz (85407225-fc3f-48a8-acda-c84a05df6837)",
"Date": "3/4/2015 12:26:24 PM",
"AppVersion": "2.0.4-beta",
"FileVersion": 4
},
"Body": {
"SavedInDeclMode": false,
"ModelName": "Generic 24t Coach",
"Inertia": 0.0,
"TracInt": 1.0,
"Gears": [
{
"Ratio": 3.240355,
"LossMap": "Axle.vtlm"
},
{
"Ratio": 6.38,
"LossMap": "Indirect Gear.vtlm",
"TCactive": false,
"ShiftPolygon": "ShiftPolygons.vgbs"
},
{
"Ratio": 4.63,
"LossMap": "Indirect Gear.vtlm",
"TCactive": false,
"ShiftPolygon": "ShiftPolygons.vgbs"
},
{
"Ratio": 3.44,
"LossMap": "Indirect Gear.vtlm",
"TCactive": false,
"ShiftPolygon": "ShiftPolygons.vgbs"
},
{
"Ratio": 2.59,
"LossMap": "Indirect Gear.vtlm",
"TCactive": false,
"ShiftPolygon": "ShiftPolygons.vgbs"
},
{
"Ratio": 1.86,
"LossMap": "Indirect Gear.vtlm",
"TCactive": false,
"ShiftPolygon": "ShiftPolygons.vgbs"
},
{
"Ratio": 1.35,
"LossMap": "Indirect Gear.vtlm",
"TCactive": false,
"ShiftPolygon": "ShiftPolygons.vgbs"
},
{
"Ratio": 1.0,
"LossMap": "Direct Gear.vtlm",
"TCactive": false,
"ShiftPolygon": "ShiftPolygons.vgbs"
},
{
"Ratio": 0.76,
"LossMap": "Indirect Gear.vtlm",
"TCactive": false,
"ShiftPolygon": "ShiftPolygons.vgbs"
}
],
"TqReserve": 20.0,
"SkipGears": true,
"ShiftTime": 2,
"EaryShiftUp": true,
"StartTqReserve": 20.0,
"StartSpeed": 2.0,
"StartAcc": 0.6,
"GearboxType": "AMT",
"TorqueConverter": {
"Enabled": false,
"File": "<NOFILE>",
"RefRPM": 0.0,
"Inertia": 0.0
}
}
}
\ No newline at end of file
Input Speed [rpm],Input Torque [Nm],Torque Loss [Nm],Eff [-]
0,-2500,77.5
0,-1500,62.5
0,-500,47.5
0,500,47.5
0,1500,62.5
0,2500,77.5
0,3500,92.5
0,4500,107.5
0,5500,122.5
0,6500,137.5
0,7500,152.5
0,8500,167.5
0,9500,182.5
0,10500,197.5
0,11500,212.5
0,12500,227.5
0,13500,242.5
0,14500,257.5
0,15500,272.5
200,-2500,77.5
200,-1500,62.5
200,-500,47.5
200,500,47.5
200,1500,62.5
200,2500,77.5
200,3500,92.5
200,4500,107.5
200,5500,122.5
200,6500,137.5
200,7500,152.5
200,8500,167.5
200,9500,182.5
200,10500,197.5
200,11500,212.5
200,12500,227.5
200,13500,242.5
200,14500,257.5
200,15500,272.5
400,-2500,77.5
400,-1500,62.5
400,-500,47.5
400,500,47.5
400,1500,62.5
400,2500,77.5
400,3500,92.5
400,4500,107.5
400,5500,122.5
400,6500,137.5
400,7500,152.5
400,8500,167.5
400,9500,182.5
400,10500,197.5
400,11500,212.5
400,12500,227.5
400,13500,242.5
400,14500,257.5
400,15500,272.5
600,-2500,77.5
600,-1500,62.5
600,-500,47.5
600,500,47.5
600,1500,62.5
600,2500,77.5
600,3500,92.5
600,4500,107.5
600,5500,122.5
600,6500,137.5
600,7500,152.5
600,8500,167.5
600,9500,182.5
600,10500,197.5
600,11500,212.5
600,12500,227.5
600,13500,242.5
600,14500,257.5
600,15500,272.5
800,-2500,77.5
800,-1500,62.5
800,-500,47.5
800,500,47.5
800,1500,62.5
800,2500,77.5
800,3500,92.5
800,4500,107.5
800,5500,122.5
800,6500,137.5
800,7500,152.5
800,8500,167.5
800,9500,182.5
800,10500,197.5
800,11500,212.5
800,12500,227.5
800,13500,242.5
800,14500,257.5
800,15500,272.5
1000,-2500,77.5
1000,-1500,62.5
1000,-500,47.5
1000,500,47.5
1000,1500,62.5
1000,2500,77.5
1000,3500,92.5
1000,4500,107.5
1000,5500,122.5
1000,6500,137.5
1000,7500,152.5
1000,8500,167.5
1000,9500,182.5
1000,10500,197.5
1000,11500,212.5
1000,12500,227.5
1000,13500,242.5
1000,14500,257.5
1000,15500,272.5
1200,-2500,77.5
1200,-1500,62.5
1200,-500,47.5
1200,500,47.5
1200,1500,62.5
1200,2500,77.5
1200,3500,92.5
1200,4500,107.5
1200,5500,122.5
1200,6500,137.5
1200,7500,152.5
1200,8500,167.5
1200,9500,182.5
1200,10500,197.5
1200,11500,212.5
1200,12500,227.5
1200,13500,242.5
1200,14500,257.5
1200,15500,272.5
1400,-2500,77.5
1400,-1500,62.5
1400,-500,47.5
1400,500,47.5
1400,1500,62.5
1400,2500,77.5
1400,3500,92.5
1400,4500,107.5
1400,5500,122.5
1400,6500,137.5
1400,7500,152.5
1400,8500,167.5
1400,9500,182.5
1400,10500,197.5
1400,11500,212.5
1400,12500,227.5
1400,13500,242.5
1400,14500,257.5
1400,15500,272.5
1600,-2500,77.5
1600,-1500,62.5
1600,-500,47.5
1600,500,47.5
1600,1500,62.5
1600,2500,77.5
1600,3500,92.5
1600,4500,107.5
1600,5500,122.5
1600,6500,137.5
1600,7500,152.5
1600,8500,167.5
1600,9500,182.5
1600,10500,197.5
1600,11500,212.5
1600,12500,227.5
1600,13500,242.5
1600,14500,257.5
1600,15500,272.5
1800,-2500,77.5
1800,-1500,62.5
1800,-500,47.5
1800,500,47.5
1800,1500,62.5
1800,2500,77.5
1800,3500,92.5
1800,4500,107.5
1800,5500,122.5
1800,6500,137.5
1800,7500,152.5
1800,8500,167.5
1800,9500,182.5
1800,10500,197.5
1800,11500,212.5
1800,12500,227.5
1800,13500,242.5
1800,14500,257.5
1800,15500,272.5
2000,-2500,77.5
2000,-1500,62.5
2000,-500,47.5
2000,500,47.5
2000,1500,62.5
2000,2500,77.5
2000,3500,92.5
2000,4500,107.5
2000,5500,122.5
2000,6500,137.5
2000,7500,152.5
2000,8500,167.5
2000,9500,182.5
2000,10500,197.5
2000,11500,212.5
2000,12500,227.5
2000,13500,242.5
2000,14500,257.5
2000,15500,272.5
2200,-2500,77.5
2200,-1500,62.5
2200,-500,47.5
2200,500,47.5
2200,1500,62.5
2200,2500,77.5
2200,3500,92.5
2200,4500,107.5
2200,5500,122.5
2200,6500,137.5
2200,7500,152.5
2200,8500,167.5
2200,9500,182.5
2200,10500,197.5
2200,11500,212.5
2200,12500,227.5
2200,13500,242.5
2200,14500,257.5
2200,15500,272.5
2400,-2500,77.5
2400,-1500,62.5
2400,-500,47.5
2400,500,47.5
2400,1500,62.5
2400,2500,77.5
2400,3500,92.5
2400,4500,107.5
2400,5500,122.5
2400,6500,137.5
2400,7500,152.5
2400,8500,167.5
2400,9500,182.5
2400,10500,197.5
2400,11500,212.5
2400,12500,227.5
2400,13500,242.5
2400,14500,257.5
2400,15500,272.5
2600,-2500,77.5
2600,-1500,62.5
2600,-500,47.5
2600,500,47.5
2600,1500,62.5
2600,2500,77.5
2600,3500,92.5
2600,4500,107.5
2600,5500,122.5
2600,6500,137.5
2600,7500,152.5
2600,8500,167.5
2600,9500,182.5
2600,10500,197.5
2600,11500,212.5
2600,12500,227.5
2600,13500,242.5
2600,14500,257.5
2600,15500,272.5
Input Speed [rpm],Input Torque [Nm],Torque Loss [Nm],Eff [-]
0,-350,6.81,
0,-150,5.81,
0,50,5.31,
0,250,6.31,
0,450,7.31,
0,650,8.31,
0,850,9.31,
0,1050,10.31,
0,1250,11.31,
0,1450,12.31,
0,1650,13.31,
0,1850,14.31,
0,2050,15.31,
0,2250,16.31,
0,2450,17.31,
200,-350,7.822,
200,-150,6.822,
200,50,6.322,
200,250,7.322,
200,450,8.322,
200,650,9.322,
200,850,10.322,
200,1050,11.322,
200,1250,12.322,
200,1450,13.322,
200,1650,14.322,
200,1850,15.322,
200,2050,16.322,
200,2250,17.322,
200,2450,18.322,
400,-350,8.834,
400,-150,7.834,
400,50,7.334,
400,250,8.334,
400,450,9.334,
400,650,10.334,
400,850,11.334,
400,1050,12.334,
400,1250,13.334,
400,1450,14.334,
400,1650,15.334,
400,1850,16.334,
400,2050,17.334,
400,2250,18.334,
400,2450,19.334,
600,-350,9.846,
600,-150,8.846,
600,50,8.346,
600,250,9.346,
600,450,10.346,
600,650,11.346,
600,850,12.346,
600,1050,13.346,
600,1250,14.346,
600,1450,15.346,
600,1650,16.346,
600,1850,17.346,
600,2050,18.346,
600,2250,19.346,
600,2450,20.346,
800,-350,10.858,
800,-150,9.858,
800,50,9.358,
800,250,10.358,
800,450,11.358,
800,650,12.358,
800,850,13.358,
800,1050,14.358,
800,1250,15.358,
800,1450,16.358,
800,1650,17.358,
800,1850,18.358,
800,2050,19.358,
800,2250,20.358,
800,2450,21.358,
1000,-350,11.87,
1000,-150,10.87,
1000,50,10.37,
1000,250,11.37,
1000,450,12.37,
1000,650,13.37,
1000,850,14.37,
1000,1050,15.37,
1000,1250,16.37,
1000,1450,17.37,
1000,1650,18.37,
1000,1850,19.37,
1000,2050,20.37,
1000,2250,21.37,
1000,2450,22.37,
1200,-350,12.882,
1200,-150,11.882,
1200,50,11.382,
1200,250,12.382,
1200,450,13.382,
1200,650,14.382,
1200,850,15.382,
1200,1050,16.382,
1200,1250,17.382,
1200,1450,18.382,
1200,1650,19.382,
1200,1850,20.382,
1200,2050,21.382,
1200,2250,22.382,
1200,2450,23.382,
1400,-350,13.894,
1400,-150,12.894,
1400,50,12.394,
1400,250,13.394,
1400,450,14.394,
1400,650,15.394,
1400,850,16.394,
1400,1050,17.394,
1400,1250,18.394,
1400,1450,19.394,
1400,1650,20.394,
1400,1850,21.394,
1400,2050,22.394,
1400,2250,23.394,
1400,2450,24.394,
1600,-350,14.906,
1600,-150,13.906,
1600,50,13.406,
1600,250,14.406,
1600,450,15.406,
1600,650,16.406,
1600,850,17.406,
1600,1050,18.406,
1600,1250,19.406,
1600,1450,20.406,
1600,1650,21.406,
1600,1850,22.406,
1600,2050,23.406,
1600,2250,24.406,
1600,2450,25.406,
1800,-350,15.918,
1800,-150,14.918,
1800,50,14.418,
1800,250,15.418,
1800,450,16.418,
1800,650,17.418,
1800,850,18.418,
1800,1050,19.418,
1800,1250,20.418,
1800,1450,21.418,
1800,1650,22.418,
1800,1850,23.418,
1800,2050,24.418,
1800,2250,25.418,
1800,2450,26.418,
2000,-350,16.93,
2000,-150,15.93,
2000,50,15.43,
2000,250,16.43,
2000,450,17.43,
2000,650,18.43,
2000,850,19.43,
2000,1050,20.43,
2000,1250,21.43,
2000,1450,22.43,
2000,1650,23.43,
2000,1850,24.43,
2000,2050,25.43,
2000,2250,26.43,
2000,2450,27.43,
0,-1000,10.06,
200,-1000,11.072,
400,-1000,12.084,
600,-1000,13.096,
800,-1000,14.108,
1000,-1000,15.12,
1200,-1000,16.132,
1400,-1000,17.144,
1600,-1000,18.156,
1800,-1000,19.168,
2000,-1000,20.18,
Input Speed [rpm],Input Torque [Nm],Torque Loss [Nm],Eff [-]
0,-350,12.06,
0,-150,8.06,
0,50,6.06,
0,250,10.06,
0,450,14.06,
0,650,18.06,
0,850,22.06,
0,1050,26.06,
0,1250,30.06,
0,1450,34.06,
0,1650,38.06,
0,1850,42.06,
0,2050,46.06,
0,2250,50.06,
0,2450,54.06,
200,-350,13.072,
200,-150,9.072,
200,50,7.072,
200,250,11.072,
200,450,15.072,
200,650,19.072,
200,850,23.072,
200,1050,27.072,
200,1250,31.072,
200,1450,35.072,
200,1650,39.072,
200,1850,43.072,
200,2050,47.072,
200,2250,51.072,
200,2450,55.072,
400,-350,14.084,
400,-150,10.084,
400,50,8.084,
400,250,12.084,
400,450,16.084,
400,650,20.084,
400,850,24.084,
400,1050,28.084,
400,1250,32.084,
400,1450,36.084,
400,1650,40.084,
400,1850,44.084,
400,2050,48.084,
400,2250,52.084,
400,2450,56.084,
600,-350,15.096,
600,-150,11.096,
600,50,9.096,
600,250,13.096,
600,450,17.096,
600,650,21.096,
600,850,25.096,
600,1050,29.096,
600,1250,33.096,
600,1450,37.096,
600,1650,41.096,
600,1850,45.096,
600,2050,49.096,
600,2250,53.096,
600,2450,57.096,
800,-350,16.108,
800,-150,12.108,
800,50,10.108,
800,250,14.108,
800,450,18.108,
800,650,22.108,
800,850,26.108,
800,1050,30.108,
800,1250,34.108,
800,1450,38.108,
800,1650,42.108,
800,1850,46.108,
800,2050,50.108,
800,2250,54.108,
800,2450,58.108,
1000,-350,17.12,
1000,-150,13.12,
1000,50,11.12,
1000,250,15.12,
1000,450,19.12,
1000,650,23.12,
1000,850,27.12,
1000,1050,31.12,
1000,1250,35.12,
1000,1450,39.12,
1000,1650,43.12,
1000,1850,47.12,
1000,2050,51.12,
1000,2250,55.12,
1000,2450,59.12,
1200,-350,18.132,
1200,-150,14.132,
1200,50,12.132,
1200,250,16.132,
1200,450,20.132,
1200,650,24.132,
1200,850,28.132,
1200,1050,32.132,
1200,1250,36.132,
1200,1450,40.132,
1200,1650,44.132,
1200,1850,48.132,
1200,2050,52.132,
1200,2250,56.132,
1200,2450,60.132,
1400,-350,19.144,
1400,-150,15.144,
1400,50,13.144,
1400,250,17.144,
1400,450,21.144,
1400,650,25.144,
1400,850,29.144,
1400,1050,33.144,
1400,1250,37.144,
1400,1450,41.144,
1400,1650,45.144,
1400,1850,49.144,
1400,2050,53.144,
1400,2250,57.144,
1400,2450,61.144,
1600,-350,20.156,
1600,-150,16.156,
1600,50,14.156,
1600,250,18.156,
1600,450,22.156,
1600,650,26.156,
1600,850,30.156,
1600,1050,34.156,
1600,1250,38.156,
1600,1450,42.156,
1600,1650,46.156,
1600,1850,50.156,
1600,2050,54.156,
1600,2250,58.156,
1600,2450,62.156,
1800,-350,21.168,
1800,-150,17.168,
1800,50,15.168,
1800,250,19.168,
1800,450,23.168,
1800,650,27.168,
1800,850,31.168,
1800,1050,35.168,
1800,1250,39.168,
1800,1450,43.168,
1800,1650,47.168,
1800,1850,51.168,
1800,2050,55.168,
1800,2250,59.168,
1800,2450,63.168,
2000,-350,22.18,
2000,-150,18.18,
2000,50,16.18,
2000,250,20.18,
2000,450,24.18,
2000,650,28.18,
2000,850,32.18,
2000,1050,36.18,
2000,1250,40.18,
2000,1450,44.18,
2000,1650,48.18,
2000,1850,52.18,
2000,2050,56.18,
2000,2250,60.18,
2000,2450,64.18,
0,-1000,25.06,
200,-1000,26.072,
400,-1000,27.084,
600,-1000,28.096,
800,-1000,29.108,
1000,-1000,30.12,
1200,-1000,31.132,
1400,-1000,32.144,
1600,-1000,33.156,
1800,-1000,34.168,
2000,-1000,35.18,
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment