Code development platform for open source projects from the European Union institutions

Skip to content
Snippets Groups Projects
Commit c4e53244 authored by Markus QUARITSCH's avatar Markus QUARITSCH
Browse files

refactoring to reduce complexity metric: 48 down to 16 (max complexity),

parent c3b3362f
No related branches found
No related tags found
No related merge requests found
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 4114 additions and 3891 deletions
VectoCore/VectoCore/Models/Simulation/Data/VectoRunData.cs
+ 196
− 172
View file @ c4e53244
......@@ -29,176 +29,200 @@
* Martin Rexeis, rexeis@ivt.tugraz.at, IVT, Graz University of Technology
*/
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Xml.Linq;
using TUGraz.VectoCommon.Exceptions;
using TUGraz.VectoCommon.Models;
using TUGraz.VectoCommon.Utils;
using TUGraz.VectoCore.Configuration;
using TUGraz.VectoCore.Models.Declaration;
using TUGraz.VectoCore.Models.SimulationComponent.Data;
using TUGraz.VectoCore.OutputData;
using DriverData = TUGraz.VectoCore.Models.SimulationComponent.Data.DriverData;
namespace TUGraz.VectoCore.Models.Simulation.Data
{
[CustomValidation(typeof(VectoRunData), "ValidateRunData")]
public class VectoRunData : SimulationComponentData
{
[ValidateObject]
public VehicleData VehicleData { get; internal set; }
[ValidateObject]
public AirdragData AirdragData { get; internal set; }
[ValidateObject]
public CombustionEngineData EngineData { get; internal set; }
[ValidateObject]
public GearboxData GearboxData { get; internal set; }
[ValidateObject]
public AxleGearData AxleGearData { get; internal set; }
[ValidateObject]
public AngledriveData AngledriveData { get; internal set; }
[Required, ValidateObject]
public IDrivingCycleData Cycle { get; internal set; }
[ValidateObject]
public IEnumerable<AuxData> Aux { get; internal set; }
public AdvancedAuxData AdvancedAux { get; internal set; }
[ValidateObject]
public RetarderData Retarder { get; internal set; }
[ValidateObject]
public PTOData PTO { get; internal set; }
[ValidateObject]
public DriverData DriverData { get; internal set; }
public ExecutionMode ExecutionMode { get; internal set; }
[Required, MinLength(1)]
public string JobName { get; internal set; }
public string ModFileSuffix { get; internal set; }
[ValidateObject]
public IDeclarationReport Report { get; internal set; }
[Required, ValidateObject]
public LoadingType Loading { get; internal set; }
[ValidateObject]
public Mission Mission { get; internal set; }
public XElement InputDataHash { get; internal set; }
public class AuxData
{
// ReSharper disable once InconsistentNaming
public string ID;
public IList<string> Technology;
[SIRange(0, 100 * Constants.Kilo)] public Watt PowerDemand;
[Required] public AuxiliaryDemandType DemandType;
[ValidateObject] public AuxiliaryData Data;
}
public static ValidationResult ValidateRunData(VectoRunData runData, ValidationContext validationContext)
{
var gearboxData = runData.GearboxData;
var engineData = runData.EngineData;
var maxSpeed = 95.KMPHtoMeterPerSecond();
if (gearboxData != null) {
var axleGearData = runData.AxleGearData;
var angledriveData = runData.AngledriveData;
var hasAngleDrive = angledriveData != null && angledriveData.Angledrive != null;
var angledriveRatio = hasAngleDrive && angledriveData.Type == AngledriveType.SeparateAngledrive
? angledriveData.Angledrive.Ratio
: 1.0;
var axlegearRatio = axleGearData != null ? axleGearData.AxleGear.Ratio : 1.0;
var dynamicTyreRadius = runData.VehicleData != null ? runData.VehicleData.DynamicTyreRadius : 0.0.SI<Meter>();
if (gearboxData.Gears.Count + 1 != engineData.FullLoadCurves.Count) {
return
new ValidationResult(
string.Format("number of full-load curves in engine does not match gear count. engine fld: {0}, gears: {1}",
engineData.FullLoadCurves.Count, gearboxData.Gears.Count));
}
foreach (var gear in gearboxData.Gears) {
for (var angularVelocity = engineData.IdleSpeed;
angularVelocity < engineData.FullLoadCurves[gear.Key].RatedSpeed;
angularVelocity += 2.0 / 3.0 * (engineData.FullLoadCurves[gear.Key].RatedSpeed - engineData.IdleSpeed) / 10.0) {
if (!gear.Value.HasLockedGear) {
continue;
}
var velocity = angularVelocity / gear.Value.Ratio / angledriveRatio / axlegearRatio * dynamicTyreRadius;
if (velocity > maxSpeed) {
continue;
}
for (var inTorque = engineData.FullLoadCurves[gear.Key].FullLoadStationaryTorque(angularVelocity) / 3;
inTorque < engineData.FullLoadCurves[gear.Key].FullLoadStationaryTorque(angularVelocity);
inTorque += 2.0 / 3.0 * engineData.FullLoadCurves[gear.Key].FullLoadStationaryTorque(angularVelocity) / 10.0) {
NewtonMeter angledriveTorque;
try {
angledriveTorque = gear.Value.LossMap.GetOutTorque(angularVelocity, inTorque);
} catch (VectoException) {
return new ValidationResult(
string.Format("Interpolation of Gear-{0}-LossMap failed with torque={1} and angularSpeed={2}", gear.Key,
inTorque, angularVelocity.ConvertTo().Rounds.Per.Minute));
}
var axlegearTorque = angledriveTorque;
try {
if (hasAngleDrive) {
axlegearTorque = angledriveData.Angledrive.LossMap.GetOutTorque(angularVelocity / gear.Value.Ratio,
angledriveTorque);
}
} catch (VectoException) {
return new ValidationResult(
string.Format("Interpolation of Angledrive-LossMap failed with torque={0} and angularSpeed={1}",
angledriveTorque, (angularVelocity / gear.Value.Ratio).ConvertTo().Rounds.Per.Minute));
}
if (axleGearData != null) {
var axleAngularVelocity = angularVelocity / gear.Value.Ratio / angledriveRatio;
try {
axleGearData.AxleGear.LossMap.GetOutTorque(axleAngularVelocity, axlegearTorque);
} catch (VectoException) {
return
new ValidationResult(
string.Format(
"Interpolation of AxleGear-LossMap failed with torque={0} and angularSpeed={1} (gear={2}, velocity={3})",
axlegearTorque, axleAngularVelocity.ConvertTo().Rounds.Per.Minute, gear.Key, velocity));
}
}
}
}
}
}
if (runData.Cycle != null && runData.Cycle.Entries.Any(e => e.PTOActive)) {
if (runData.PTO == null || runData.PTO.PTOCycle == null) {
return new ValidationResult("PTOCycle is used in DrivingCycle, but is not defined in Vehicle-Data.");
}
}
return ValidationResult.Success;
}
}
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Xml.Linq;
using TUGraz.VectoCommon.Exceptions;
using TUGraz.VectoCommon.Models;
using TUGraz.VectoCommon.Utils;
using TUGraz.VectoCore.Configuration;
using TUGraz.VectoCore.Models.Declaration;
using TUGraz.VectoCore.Models.SimulationComponent.Data;
using TUGraz.VectoCore.Models.SimulationComponent.Data.Gearbox;
using TUGraz.VectoCore.OutputData;
using DriverData = TUGraz.VectoCore.Models.SimulationComponent.Data.DriverData;
namespace TUGraz.VectoCore.Models.Simulation.Data
{
[CustomValidation(typeof(VectoRunData), "ValidateRunData")]
public class VectoRunData : SimulationComponentData
{
[ValidateObject]
public VehicleData VehicleData { get; internal set; }
[ValidateObject]
public AirdragData AirdragData { get; internal set; }
[ValidateObject]
public CombustionEngineData EngineData { get; internal set; }
[ValidateObject]
public GearboxData GearboxData { get; internal set; }
[ValidateObject]
public AxleGearData AxleGearData { get; internal set; }
[ValidateObject]
public AngledriveData AngledriveData { get; internal set; }
[Required, ValidateObject]
public IDrivingCycleData Cycle { get; internal set; }
[ValidateObject]
public IEnumerable<AuxData> Aux { get; internal set; }
public AdvancedAuxData AdvancedAux { get; internal set; }
[ValidateObject]
public RetarderData Retarder { get; internal set; }
[ValidateObject]
public PTOData PTO { get; internal set; }
[ValidateObject]
public DriverData DriverData { get; internal set; }
public ExecutionMode ExecutionMode { get; internal set; }
[Required, MinLength(1)]
public string JobName { get; internal set; }
public string ModFileSuffix { get; internal set; }
[ValidateObject]
public IDeclarationReport Report { get; internal set; }
[Required, ValidateObject]
public LoadingType Loading { get; internal set; }
[ValidateObject]
public Mission Mission { get; internal set; }
public XElement InputDataHash { get; internal set; }
public class AuxData
{
// ReSharper disable once InconsistentNaming
public string ID;
public IList<string> Technology;
[SIRange(0, 100 * Constants.Kilo)] public Watt PowerDemand;
[Required] public AuxiliaryDemandType DemandType;
[ValidateObject] public AuxiliaryData Data;
}
public static ValidationResult ValidateRunData(VectoRunData runData, ValidationContext validationContext)
{
var gearboxData = runData.GearboxData;
var engineData = runData.EngineData;
if (gearboxData != null) {
var validationResult = CheckPowertrainLossMapsSize(runData, gearboxData, engineData);
if (validationResult != null) {
return validationResult;
}
}
if (runData.Cycle != null && runData.Cycle.Entries.Any(e => e.PTOActive)) {
if (runData.PTO == null || runData.PTO.PTOCycle == null) {
return new ValidationResult("PTOCycle is used in DrivingCycle, but is not defined in Vehicle-Data.");
}
}
return ValidationResult.Success;
}
private static ValidationResult CheckPowertrainLossMapsSize(VectoRunData runData, GearboxData gearboxData,
CombustionEngineData engineData)
{
var maxSpeed = 95.KMPHtoMeterPerSecond();
var axleGearData = runData.AxleGearData;
var angledriveData = runData.AngledriveData;
var hasAngleDrive = angledriveData != null && angledriveData.Angledrive != null;
var angledriveRatio = hasAngleDrive && angledriveData.Type == AngledriveType.SeparateAngledrive
? angledriveData.Angledrive.Ratio
: 1.0;
var axlegearRatio = axleGearData != null ? axleGearData.AxleGear.Ratio : 1.0;
var dynamicTyreRadius = runData.VehicleData != null ? runData.VehicleData.DynamicTyreRadius : 0.0.SI<Meter>();
if (gearboxData.Gears.Count + 1 != engineData.FullLoadCurves.Count) {
return
new ValidationResult(
string.Format("number of full-load curves in engine does not match gear count. engine fld: {0}, gears: {1}",
engineData.FullLoadCurves.Count, gearboxData.Gears.Count));
}
foreach (var gear in gearboxData.Gears) {
for (var angularVelocity = engineData.IdleSpeed;
angularVelocity < engineData.FullLoadCurves[gear.Key].RatedSpeed;
angularVelocity += 2.0 / 3.0 * (engineData.FullLoadCurves[gear.Key].RatedSpeed - engineData.IdleSpeed) / 10.0) {
if (!gear.Value.HasLockedGear) {
continue;
}
var velocity = angularVelocity / gear.Value.Ratio / angledriveRatio / axlegearRatio * dynamicTyreRadius;
if (velocity > maxSpeed) {
continue;
}
for (var inTorque = engineData.FullLoadCurves[gear.Key].FullLoadStationaryTorque(angularVelocity) / 3;
inTorque < engineData.FullLoadCurves[gear.Key].FullLoadStationaryTorque(angularVelocity);
inTorque += 2.0 / 3.0 * engineData.FullLoadCurves[gear.Key].FullLoadStationaryTorque(angularVelocity) / 10.0) {
var validateRunData = CheckLossMapsEntries(gear, angularVelocity, inTorque, angledriveData, axleGearData, velocity);
if (validateRunData != null) {
return validateRunData;
}
}
}
}
return null;
}
private static ValidationResult CheckLossMapsEntries(KeyValuePair<uint, GearData> gear, PerSecond angularVelocity,
NewtonMeter inTorque, AngledriveData angledriveData, AxleGearData axleGearData, SI velocity)
{
var hasAngleDrive = angledriveData != null && angledriveData.Angledrive != null;
var angledriveRatio = hasAngleDrive && angledriveData.Type == AngledriveType.SeparateAngledrive
? angledriveData.Angledrive.Ratio
: 1.0;
NewtonMeter angledriveTorque;
try {
angledriveTorque = gear.Value.LossMap.GetOutTorque(angularVelocity, inTorque);
} catch (VectoException) {
return new ValidationResult(
string.Format("Interpolation of Gear-{0}-LossMap failed with torque={1} and angularSpeed={2}", gear.Key,
inTorque, angularVelocity.ConvertTo().Rounds.Per.Minute));
}
var axlegearTorque = angledriveTorque;
try {
if (hasAngleDrive) {
axlegearTorque = angledriveData.Angledrive.LossMap.GetOutTorque(angularVelocity / gear.Value.Ratio,
angledriveTorque);
}
} catch (VectoException) {
return new ValidationResult(
string.Format("Interpolation of Angledrive-LossMap failed with torque={0} and angularSpeed={1}",
angledriveTorque, (angularVelocity / gear.Value.Ratio).ConvertTo().Rounds.Per.Minute));
}
if (axleGearData != null) {
var axleAngularVelocity = angularVelocity / gear.Value.Ratio / angledriveRatio;
try {
axleGearData.AxleGear.LossMap.GetOutTorque(axleAngularVelocity, axlegearTorque);
} catch (VectoException) {
return
new ValidationResult(
string.Format(
"Interpolation of AxleGear-LossMap failed with torque={0} and angularSpeed={1} (gear={2}, velocity={3})",
axlegearTorque, axleAngularVelocity.ConvertTo().Rounds.Per.Minute, gear.Key, velocity));
}
}
return null;
}
}
}
\ No newline at end of file
VectoCore/VectoCore/Models/Simulation/Impl/SimulatorFactory.cs
+ 199
− 162
View file @ c4e53244
......@@ -29,166 +29,203 @@
* Martin Rexeis, rexeis@ivt.tugraz.at, IVT, Graz University of Technology
*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading;
using TUGraz.VectoCommon.Exceptions;
using TUGraz.VectoCommon.InputData;
using TUGraz.VectoCommon.Models;
using TUGraz.VectoCommon.Utils;
using TUGraz.VectoCore.InputData;
using TUGraz.VectoCore.InputData.Reader.Impl;
using TUGraz.VectoCore.Models.Declaration;
using TUGraz.VectoCore.Models.SimulationComponent.Data;
using TUGraz.VectoCore.OutputData;
using TUGraz.VectoCore.OutputData.ModFilter;
using TUGraz.VectoCore.OutputData.XML;
namespace TUGraz.VectoCore.Models.Simulation.Impl
{
public class SimulatorFactory : LoggingObject
{
private static int _jobNumberCounter;
private readonly ExecutionMode _mode;
private readonly bool _engineOnlyMode;
public SimulatorFactory(ExecutionMode mode, IInputDataProvider dataProvider, IOutputDataWriter writer,
IDeclarationReport declarationReport = null, bool validate = true)
{
Log.Info("########## VectoCore Version {0} ##########", Assembly.GetExecutingAssembly().GetName().Version);
JobNumber = Interlocked.Increment(ref _jobNumberCounter);
_mode = mode;
ModWriter = writer;
Validate = validate;
int workerThreads;
int completionThreads;
ThreadPool.GetMinThreads(out workerThreads, out completionThreads);
if (workerThreads < 12) {
workerThreads = 12;
}
ThreadPool.SetMinThreads(workerThreads, completionThreads);
switch (mode) {
case ExecutionMode.Declaration:
var declDataProvider = dataProvider as IDeclarationInputDataProvider;
if (declDataProvider == null) {
throw new VectoException("InputDataProvider does not implement DeclarationData interface");
}
var report = declarationReport ?? new XMLDeclarationReport(writer);
DataReader = new DeclarationModeVectoRunDataFactory(declDataProvider, report);
break;
case ExecutionMode.Engineering:
var engDataProvider = dataProvider as IEngineeringInputDataProvider;
if (engDataProvider == null) {
throw new VectoException("InputDataProvider does not implement Engineering interface");
}
if (engDataProvider.JobInputData().EngineOnlyMode) {
DataReader = new EngineOnlyVectoRunDataFactory(engDataProvider);
_engineOnlyMode = true;
} else {
DataReader = new EngineeringModeVectoRunDataFactory(engDataProvider);
}
break;
default:
throw new VectoException("Unkown factory mode in SimulatorFactory: {0}", mode);
}
}
public bool Validate { get; set; }
public IVectoRunDataFactory DataReader { get; private set; }
public SummaryDataContainer SumData { get; set; }
public IOutputDataWriter ModWriter { get; private set; }
public int JobNumber { get; set; }
public bool WriteModalResults { get; set; }
public bool ModalResults1Hz { get; set; }
public bool ActualModalData { get; set; }
/// <summary>
/// Creates powertrain and initializes it with the component's data.
/// </summary>
/// <returns>new VectoRun Instance</returns>
public IEnumerable<IVectoRun> SimulationRuns()
{
var i = 0;
var modDataFilter = ModalResults1Hz
? new IModalDataFilter[] { new ModalData1HzFilter() }
: null;
if (ActualModalData) {
modDataFilter = new IModalDataFilter[] { new ActualModalDataFilter(), };
}
var warning1Hz = false;
foreach (var data in DataReader.NextRun()) {
var d = data;
if (d.Report != null) {
d.Report.PrepareResult(d.Loading, d.Mission, d);
}
Action<ModalDataContainer> addReportResult = writer => {
if (d.Report != null) {
d.Report.AddResult(d.Loading, d.Mission, d, writer);
}
};
if (!data.Cycle.CycleType.IsDistanceBased() && ModalResults1Hz && !warning1Hz) {
Log.Error("Output filter for 1Hz results is only available for distance-based cycles!");
warning1Hz = true;
}
IModalDataContainer modContainer =
new ModalDataContainer(data, ModWriter,
addReportResult: _mode == ExecutionMode.Declaration ? addReportResult : null,
writeEngineOnly: _engineOnlyMode,
filter: data.Cycle.CycleType.IsDistanceBased() && ModalResults1Hz || ActualModalData ? modDataFilter : null) {
WriteAdvancedAux = data.AdvancedAux != null && data.AdvancedAux.AuxiliaryAssembly == AuxiliaryModel.Advanced,
WriteModalResults = _mode != ExecutionMode.Declaration || WriteModalResults
};
var current = i++;
var builder = new PowertrainBuilder(modContainer, modData => {
if (SumData != null) {
SumData.Write(modData, JobNumber, current, d);
//SumData.Write(modContainer, d.JobName, string.Format("{0}-{1}", JobNumber, current),
// d.Cycle.Name + Constants.FileExtensions.CycleFile, mass, loading, volume ?? 0.SI<CubicMeter>(), gearCount);
}
});
VectoRun run;
switch (data.Cycle.CycleType) {
case CycleType.DistanceBased:
run = new DistanceRun(builder.Build(data));
break;
case CycleType.EngineOnly:
case CycleType.PWheel:
case CycleType.MeasuredSpeed:
case CycleType.MeasuredSpeedGear:
run = new TimeRun(builder.Build(data));
break;
case CycleType.PTO:
throw new VectoException("PTO Cycle can not be used as main cycle!");
default:
throw new ArgumentOutOfRangeException("CycleType unknown:" + data.Cycle.CycleType);
}
if (Validate) {
var validationErrors = run.Validate(_mode, data.GearboxData == null ? (GearboxType?)null : data.GearboxData.Type,
data.Mission != null && data.Mission.MissionType.IsEMS());
if (validationErrors.Any()) {
throw new VectoException("Validation of Run-Data Failed: " +
string.Join("\n", validationErrors.Select(r => r.ErrorMessage + string.Join("; ", r.MemberNames))));
}
}
yield return run;
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading;
using TUGraz.VectoCommon.Exceptions;
using TUGraz.VectoCommon.InputData;
using TUGraz.VectoCommon.Models;
using TUGraz.VectoCommon.Utils;
using TUGraz.VectoCore.InputData;
using TUGraz.VectoCore.InputData.Reader.Impl;
using TUGraz.VectoCore.Models.Declaration;
using TUGraz.VectoCore.Models.Simulation.Data;
using TUGraz.VectoCore.Models.SimulationComponent.Data;
using TUGraz.VectoCore.OutputData;
using TUGraz.VectoCore.OutputData.ModFilter;
using TUGraz.VectoCore.OutputData.XML;
namespace TUGraz.VectoCore.Models.Simulation.Impl
{
public class SimulatorFactory : LoggingObject
{
private static int _jobNumberCounter;
private readonly ExecutionMode _mode;
private bool _engineOnlyMode;
public SimulatorFactory(ExecutionMode mode, IInputDataProvider dataProvider, IOutputDataWriter writer,
IDeclarationReport declarationReport = null, bool validate = true)
{
Log.Info("########## VectoCore Version {0} ##########", Assembly.GetExecutingAssembly().GetName().Version);
JobNumber = Interlocked.Increment(ref _jobNumberCounter);
_mode = mode;
ModWriter = writer;
Validate = validate;
int workerThreads;
int completionThreads;
ThreadPool.GetMinThreads(out workerThreads, out completionThreads);
if (workerThreads < 12) {
workerThreads = 12;
}
ThreadPool.SetMinThreads(workerThreads, completionThreads);
switch (mode) {
case ExecutionMode.Declaration:
var declDataProvider = ToDeclarationInputDataProvider(dataProvider);
var report = declarationReport ?? new XMLDeclarationReport(writer);
DataReader = new DeclarationModeVectoRunDataFactory(declDataProvider, report);
break;
case ExecutionMode.Engineering:
CreateEngineeringDataReader(dataProvider);
break;
default:
throw new VectoException("Unkown factory mode in SimulatorFactory: {0}", mode);
}
}
private void CreateEngineeringDataReader(IInputDataProvider dataProvider)
{
var engDataProvider = ToEngineeringInputDataProvider(dataProvider);
if (engDataProvider.JobInputData().EngineOnlyMode) {
DataReader = new EngineOnlyVectoRunDataFactory(engDataProvider);
_engineOnlyMode = true;
} else {
DataReader = new EngineeringModeVectoRunDataFactory(engDataProvider);
}
}
private static IDeclarationInputDataProvider ToDeclarationInputDataProvider(IInputDataProvider dataProvider)
{
var declDataProvider = dataProvider as IDeclarationInputDataProvider;
if (declDataProvider == null) {
throw new VectoException("InputDataProvider does not implement DeclarationData interface");
}
return declDataProvider;
}
private static IEngineeringInputDataProvider ToEngineeringInputDataProvider(IInputDataProvider dataProvider)
{
var engDataProvider = dataProvider as IEngineeringInputDataProvider;
if (engDataProvider == null) {
throw new VectoException("InputDataProvider does not implement Engineering interface");
}
return engDataProvider;
}
public bool Validate { get; set; }
public IVectoRunDataFactory DataReader { get; private set; }
public SummaryDataContainer SumData { get; set; }
public IOutputDataWriter ModWriter { get; private set; }
public int JobNumber { get; set; }
public bool WriteModalResults { get; set; }
public bool ModalResults1Hz { get; set; }
public bool ActualModalData { get; set; }
/// <summary>
/// Creates powertrain and initializes it with the component's data.
/// </summary>
/// <returns>new VectoRun Instance</returns>
public IEnumerable<IVectoRun> SimulationRuns()
{
var i = 0;
var warning1Hz = false;
foreach (var data in DataReader.NextRun()) {
var d = data;
var addReportResult = PrepareReport(data);
if (!data.Cycle.CycleType.IsDistanceBased() && ModalResults1Hz && !warning1Hz) {
Log.Error("Output filter for 1Hz results is only available for distance-based cycles!");
warning1Hz = true;
}
IModalDataContainer modContainer =
new ModalDataContainer(data, ModWriter,
addReportResult: _mode == ExecutionMode.Declaration ? addReportResult : null,
writeEngineOnly: _engineOnlyMode,
filter: GetModDataFilter(data)) {
WriteAdvancedAux = data.AdvancedAux != null && data.AdvancedAux.AuxiliaryAssembly == AuxiliaryModel.Advanced,
WriteModalResults = _mode != ExecutionMode.Declaration || WriteModalResults
};
var current = i++;
var builder = new PowertrainBuilder(modContainer, modData => {
if (SumData != null) {
SumData.Write(modData, JobNumber, current, d);
}
});
var run = GetVectoRun(data, builder);
if (Validate) {
ValidateVectoRunData(run, data.GearboxData == null ? (GearboxType?)null : data.GearboxData.Type,
data.Mission != null && data.Mission.MissionType.IsEMS());
}
yield return run;
}
}
private IModalDataFilter[] GetModDataFilter(VectoRunData data)
{
var modDataFilter = ModalResults1Hz
? new IModalDataFilter[] { new ModalData1HzFilter() }
: null;
if (ActualModalData) {
modDataFilter = new IModalDataFilter[] { new ActualModalDataFilter(), };
}
return data.Cycle.CycleType.IsDistanceBased() && ModalResults1Hz || ActualModalData ? modDataFilter : null;
}
private void ValidateVectoRunData(VectoRun run, GearboxType? gearboxtype, bool isEms)
{
var validationErrors = run.Validate(_mode, gearboxtype, isEms);
if (validationErrors.Any()) {
throw new VectoException("Validation of Run-Data Failed: " +
string.Join("\n", validationErrors.Select(r => r.ErrorMessage + string.Join("; ", r.MemberNames))));
}
}
private static VectoRun GetVectoRun(VectoRunData data, PowertrainBuilder builder)
{
VectoRun run;
switch (data.Cycle.CycleType) {
case CycleType.DistanceBased:
run = new DistanceRun(builder.Build(data));
break;
case CycleType.EngineOnly:
case CycleType.PWheel:
case CycleType.MeasuredSpeed:
case CycleType.MeasuredSpeedGear:
run = new TimeRun(builder.Build(data));
break;
case CycleType.PTO:
throw new VectoException("PTO Cycle can not be used as main cycle!");
default:
throw new ArgumentOutOfRangeException("CycleType unknown:" + data.Cycle.CycleType);
}
return run;
}
private static Action<ModalDataContainer> PrepareReport(VectoRunData data)
{
if (data.Report != null) {
data.Report.PrepareResult(data.Loading, data.Mission, data);
}
Action<ModalDataContainer> addReportResult = writer => {
if (data.Report != null) {
data.Report.AddResult(data.Loading, data.Mission, data, writer);
}
};
return addReportResult;
}
}
}
\ No newline at end of file
VectoCore/VectoCore/OutputData/SummaryDataContainer.cs
+ 411
− 394
View file @ c4e53244
This diff is collapsed.
VectoCore/VectoCore/Utils/VectoCSVFile.cs
+ 2
− 6
View file @ c4e53244
......@@ -147,12 +147,8 @@ namespace TUGraz.VectoCore.Utils
table.Columns.Add(col);
}
if (p.EndOfData) {
return;
}
var lineNumber = 1;
do {
while (!p.EndOfData) {
string[] cells = { };
if (firstLineIsData) {
cells = colsWithoutComment;
......@@ -179,7 +175,7 @@ namespace TUGraz.VectoCore.Utils
string.Format("Line {0}: The data format of a value is not correct. {1}", lineNumber, e.Message), e);
}
lineNumber++;
} while (!p.EndOfData);
}
}
/// <summary>
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

For further information about the platform and support, please see https://code.europa.eu/info/about