private IEnumerable <PsaTrace> EnumerateSelectedTraces(
IEnumerable <ExportablePsaTraceViewModel> unfiltered)
{
foreach (ExportablePsaTraceViewModel trace in unfiltered.Where(
t => t.IsSelectedForExport))
{
var res = new PsaTrace();
trace.Model.CopyTo(res);
foreach (ExportablePsaParametersSetViewModel vm in
trace.ParametersSets.Where(
ps => ps.IsSelectedForExport))
{
var set = new PsaParametersSet();
vm.Model.CopyTo(set);
foreach (PsaParameterDataViewModel pd in vm.Parameters)
{
var data = new PsaParameterData(pd.Model.OriginalTypeId);
pd.Model.CopyTo(data);
set.Parameters.Add(data);
}
res.ParametersSets.Add(set);
}
yield return(res);
}
}
/// <summary>
/// Deserialization logic.
/// </summary>
/// <param name="parameterElement"></param>
private PsaParameterData DeserializeParameterData(XElement parameterElement)
{
string sourceParamSetIdNameResolved = ParametersSetIdName;
//mgr.GetString(SourceParamSetIdName);
PsaParameterData data = new PsaParameterData(parameterElement.Element(OriginalTypeId).Value);
data.Id = long.Parse(parameterElement.Element(IdName).Value);
data.HasTimestamps = Boolean.Parse(parameterElement.Element(HasTimestampsName).Value);
data.PsaParametersSetId = long.Parse(parameterElement.Element(sourceParamSetIdNameResolved).Value);
data.Type = (PsaParameterType)Int32.Parse(parameterElement.Element(TypeName).Value);
data.Units = (Unit)Int32.Parse(parameterElement.Element(UnitsName).Value);
XElement valuesElement = parameterElement.Element(ValuesName);
foreach (XElement valueElement in valuesElement.Elements(ValueName))
{
data.Values.Add(valueElement.Value);
}
if (data.HasTimestamps)
{
XElement timestampsElement =
parameterElement.Element(TimestampsName);
foreach (XElement timestampElement in
timestampsElement.Elements(TimestampName))
{
data.Timestamps.Add(Int32.Parse(timestampElement.Value));
}
}
return(data);
}
public PsaParameterDataViewModel(PsaParameterData model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
this.model = model;
foreach (string v in model.Values)
{
double val = double.NaN;
double.TryParse(v, NumberStyles.Float,
CultureInfo.InvariantCulture, out val);
values.Add(val);
}
if (model.HasTimestamps)
{
foreach (int ts in model.Timestamps)
{
timestamps.Add(ts);
}
}
unitsViewModel = new UnitsViewModel(model.Units);
}
private void ExtractForInjector(PsaParametersSet set,
AnalyticStatisticsItem result, int injectorNumber,
DateTime sourceDataCaptureDateTime)
{
PsaParameterData forThisInjector =
set.GetCertainInjectorCorrections(injectorNumber);
if (forThisInjector == null)
{
return;
}
PsaParameterData rpmData =
set.GetParameterOfType(PsaParameterType.EngineRpm);
CorrelatedMedianExtractor extractor =
new CorrelatedMedianExtractor(
rpmData.GetDoubles(), forThisInjector.GetDoubles(),
RpmCorrelationThresholdPercentage);
double res = extractor.GetForBaseValue((int)RuleTypeToRpm.Map(type));
if (double.IsNaN(res))
{
return;
}
// becuse we need correction's absolute value, it can be negative
double abs = Math.Abs(res);
result.Values.Add(new AnalyticStatisticsValue(
abs, info.Vin, set.Id, sourceDataCaptureDateTime));
}
private void ExtractDataFromTrace(PsaTrace trace)
{
DateTime date = trace.Date;
foreach (PsaParametersSet set in trace.ParametersSets)
{
PsaParameterData rpmData =
set.GetParameterOfType(PsaParameterType.EngineRpm);
PsaParameterData waterData =
set.GetParameterOfType(
PsaParameterType.WaterTemperature);
if (waterData == null)
{
waterData = set.GetParameterOfType(
PsaParameterType.EngineCoolantTemperature);
}
if (rpmData != null && waterData != null)
{
if (RpmDataFits(rpmData))
{
HelperRpmWaterDate result = new
HelperRpmWaterDate(rpmData, waterData, date);
ProcessHelper(result);
}
}
}
}
private double ExtractMedianCorrectionValueForRpm(
PsaParameterData injectorDataParam, IList <int> indexes)
{
IList <double> line = new List <double>();
foreach (int index in indexes)
{
double d;
double.TryParse(injectorDataParam.Values[index],
NumberStyles.Float,
CultureInfo.InvariantCulture, out d);
line.Add(d);
}
double result;
if (line.Count != 0)
{
result = line.Average();
}
else
{
result = double.NaN;
}
return(result);
}
public static PsaParameterData FromDtoToDomainObject(PsaParameterDataDto source)
{
var target = new PsaParameterData(source.OriginalTypeId)
{
Id = source.Id,
HasTimestamps = source.HasTimestamps,
PsaParametersSetId = source.PsaParametersSetId,
OriginalTypeId = source.OriginalTypeId,
AdditionalSourceInfo = source.AdditionalSourceInfo,
Type = (PsaParameterType)source.Type,
Units = (Unit)source.Units
};
if (source.HasTimestamps)
{
foreach (int ts in source.Timestamps)
{
target.Timestamps.Add(ts);
}
}
foreach (string s in source.Values)
{
target.Values.Add(s);
}
return(target);
}
public HelperRpmWaterDate(PsaParameterData rpmData,
PsaParameterData waterTempData,
DateTime date)
{
Date = date;
if (rpmData.Type != PsaParameterType.EngineRpm)
{
throw new ArgumentException("Engine RPM parameter expected!");
}
if (waterTempData.Type != PsaParameterType.WaterTemperature &&
waterTempData.Type !=
PsaParameterType.EngineCoolantTemperature)
{
throw new ArgumentException(
"EngineCoolant temperature parameter expected!");
}
foreach (string s in rpmData.Values)
{
rpmValues.Add(Double.Parse(s, NumberStyles.Float,
CultureInfo.InvariantCulture));
}
foreach (string s in waterTempData.Values)
{
waterTempValues.Add(Double.Parse(s, NumberStyles.Float,
CultureInfo.InvariantCulture));
}
temperatureClass = DetermineTemperatureClass(waterTempValues);
}
private PsaParametersSet GenerateParametersSet()
{
var result = new PsaParametersSet()
{
AdditionalSourceInfo = "SourceInfo",
EcuLabel = "ECU LABEL",
EcuName = "ESCU1",
Id = 21,
OriginalName = "Orig Name",
OriginalTypeId = "@123-GG",
PsaTraceId = 23,
Type = PsaParametersSetType.Mixed
};
var rpmData = new PsaParameterData("Engine RPM")
{
AdditionalSourceInfo = "Add source info",
HasTimestamps = false,
Id = 34,
OriginalName = "Engine RPM",
OriginalTypeId = "Eng RPMMM",
PsaParametersSetId = 21,
Type = PsaParameterType.EngineRpm,
Units = Unit.Rpm
};
rpmData.Values.Clear();
rpmData.Values.Add("720");
rpmData.Values.Add("720");
rpmData.Values.Add("1200");
rpmData.Values.Add("1300");
rpmData.Values.Add("1300");
rpmData.Values.Add("1400");
rpmData.Values.Add("1200");
rpmData.Values.Add("720");
result.Parameters.Add(rpmData);
var otherData = new PsaParameterData("EngineRpm")
{
AdditionalSourceInfo = "Add source info",
HasTimestamps = false,
Id = 34,
OriginalName = "Engine RPM",
OriginalTypeId = "Eng RPMMM",
PsaParametersSetId = 21,
Timestamps = { },
Type = PsaParameterType.OilPressure,
Units = Unit.Bar
};
otherData.Values.Clear();
otherData.Values.Add("72");
otherData.Values.Add("72");
otherData.Values.Add("120");
otherData.Values.Add("130");
otherData.Values.Add("130");
otherData.Values.Add("140");
otherData.Values.Add("120");
otherData.Values.Add("72");
result.Parameters.Add(otherData);
return(result);
}
public static PsaParameterDataDto FromDomainObjectToDto(PsaParameterData source)
{
var target = new PsaParameterDataDto();
target.Id = source.Id;
target.HasTimestamps = source.HasTimestamps;
target.PsaParametersSetId = source.PsaParametersSetId;
if (source.HasTimestamps)
{
List <int> timestamps = new List <int>();
foreach (int ts in source.Timestamps)
{
timestamps.Add(ts);
}
target.Timestamps = timestamps.ToArray();
}
target.OriginalTypeId = source.OriginalTypeId;
target.Type = (int)source.Type;
target.Units = (int)source.Units;
List <string> values = new List <string>();
foreach (string s in source.Values)
{
values.Add(s);
}
target.Values = values.ToArray();
target.AdditionalSourceInfo = source.AdditionalSourceInfo;
return(target);
}
private void PickUpFromSet(PsaParametersSet set, DateTime date)
{
if (!ParametersSetHasRequiredDataTypes(set))
{
return;
}
PsaParameterData rpmData = set.Parameters.FirstOrDefault(
p => p.Type == PsaParameterType.EngineRpm);
PsaParameterData inj1Data =
set.Parameters.FirstOrDefault(
p => p.Type == PsaParameterType.Injector1Correction);
PsaParameterData inj2Data =
set.Parameters.FirstOrDefault(
p => p.Type == PsaParameterType.Injector2Correction);
PsaParameterData inj3Data =
set.Parameters.FirstOrDefault(
p => p.Type == PsaParameterType.Injector3Correction);
PsaParameterData inj4Data =
set.Parameters.FirstOrDefault(
p => p.Type == PsaParameterType.Injector4Correction);
if (rpmData != null)
{
GenerateFromParameters(rpmData,
inj1Data, inj2Data, inj3Data, inj4Data, date);
}
}
public AnalyticStatisticsItem Get(PsaParametersSet set,
DateTime sourceDataCaptureDateTime)
{
AnalyticStatisticsItem result = new AnalyticStatisticsItem(Type,
VehicleInfo.Engine.Family.Type, VehicleInfo.Engine.Type);
PsaParameterData rpmData = set.GetParameterOfType(PsaParameterType.EngineRpm);
PsaParameterData voltageData = GetRequiredDependentData(set);
if (rpmData == null || voltageData == null)
{
throw new Exception("set does not fit.");
}
CorrelatedMedianExtractor extractor = new CorrelatedMedianExtractor(
rpmData.GetDoubles(), voltageData.GetDoubles(),
RpmCorrelationThresholdPercentage);
double doubleValue = extractor.GetForBaseValue(Convert.ToDouble(TargetRpm));
if (!double.IsNaN(doubleValue))
{
AnalyticStatisticsValue value =
new AnalyticStatisticsValue(doubleValue, info.Vin, set.Id,
sourceDataCaptureDateTime);
result.Values.Add(value);
}
return(result);
}
private void GenerateMedianData(PsaParameterData rpmData,
PsaParameterData injectorData, int injectorNumber, DateTime date)
{
MedianDataFactory factory =
new MedianDataFactory(rpmData, injectorData, injectorNumber);
factory.Generate(Result, date);
}
public RangeDataFactory(
PsaParameterData rpmData,
PsaParameterData injectorData,
int injectorNumber)
{
this.rpmData = rpmData;
this.injectorData = injectorData;
this.injectorNumber = injectorNumber;
}
private static IList <double> ExtractInitialIdleLine(
PsaParameterData data)
{
IList <double> doubles = new List <double>();
foreach (string s in data.Values)
{
doubles.Add(Double.Parse(s));
}
return(IdleRpmValueExtractor.ExtractInitialIdleLine(doubles));
}
/// <summary>
/// Provides a view for PsaParameterData
/// </summary>
public PartialViewResult ParameterChart(long parameterDataId)
{
PsaParameterDataDto dto = service.GetParameterById(parameterDataId);
if (dto == null)
{
return(new PartialViewResult());
}
PsaParameterData model = PsaParameterDataAssembler.FromDtoToDomainObject(dto);
return(PartialView(model));
}
private void PickDataFromSet(PsaParametersSet set, DateTime date)
{
PsaParameterData rpmData =
set.GetParameterOfType(PsaParameterType.EngineRpm);
PsaParameterData pressureData =
set.GetParameterOfType(PsaParameterType.FuelSystemPressure);
IList <int> idleIndexes = IdleRpmValueExtractor.
ExtractIdleIndexes(rpmData.GetDoubles());
if (idleIndexes.Count < idleRpmValuesCountLowerThreshold)
{
return;
}
IList <double> idlePressureValues =
ExtractIdlePressureValues(idleIndexes, pressureData.GetDoubles());
result.Values.Add(
new KeyValuePair <DateTime, double>(
date, idlePressureValues.Average()));
// Let's get OcrToIdleRpmRatio
PsaParameterData ocrData =
set.GetParameterOfType(PsaParameterType.
DieselPressureRegulatorRatio);
if (ocrData != null)
{
IList <double> ocrValues =
ocrData.ExtractByIndexes(idleIndexes).ToList();
IList <double> rpmValues =
rpmData.ExtractByIndexes(idleIndexes).ToList();
if (ocrValues.Count != rpmValues.Count)
{
throw new Exception("Counts should be equal!");
}
IList <double> ratioValues = new List <double>();
for (int i = 0; i < rpmValues.Count; i++)
{
double ratio = ocrValues[i] / rpmValues[i];
if (double.IsInfinity(ratio))
{
continue;
}
ratioValues.Add(RatioMultiplier * ocrValues[i] / rpmValues[i]);
}
result.OcrToRpmRatio[date] = ratioValues.Average();
}
}
private IList <double> ExtractMedianCorrectionValuesForRpm(
PsaParameterData injectorDataset, IList <int> indexes)
{
IList <double> result = new List <double>();
foreach (int index in indexes)
{
double d;
double.TryParse(injectorDataset.Values[index],
NumberStyles.Float,
CultureInfo.InvariantCulture, out d);
result.Add(d);
}
return(result);
}
private void InitializeSetWithScreenData(PsaParametersSet set,
PeugeotScreen screen)
{
set.Type = PsaParametersSetTypeMapper.Get(screen.Name);
set.OriginalName = screen.Name;
foreach (PeugeotRawParameterPoint p in screen.Points)
{
PsaParameterData parameter = new PsaParameterData(p.ParameterName); // passed original type ID
parameter.Type = DataTypeResolver2.GetType(p.ParameterName);
parameter.OriginalName = p.ParameterName;
parameter.HasTimestamps = false;
parameter.Values.Add(p.Value);
parameter.Units = UnitsConverter.Convert(p.Units);
parameter.AdditionalSourceInfo = GenerateAdditionalSourceInfo(parameter.OriginalTypeId);
set.Parameters.Add(parameter);
}
}
public ImportablePsaParameterDataViewModel(PsaParameterData model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
this.model = model;
type = new PsaParameterTypeViewModel(model.Type);
foreach (string value in model.Values)
{
double d;
double.TryParse(value, NumberStyles.Float,
CultureInfo.InvariantCulture, out d);
values.Add(d);
}
}
private bool RpmDataFits(PsaParameterData data)
{
if (data.Type != PsaParameterType.EngineRpm)
{
throw new ArgumentException("Wrong data type!");
}
IList <double> doubles = ExtractInitialIdleLine(data);
int idlePointsCount = doubles.Count;
int totalPointsCount = data.Values.Count;
double ratio = ((double)idlePointsCount / totalPointsCount) * 100;
if (ratio >= InitialRpmLineMinLenghtPercent)
{
return(true);
}
return(false);
}
private void GenerateFromParameters(
PsaParameterData rpmData,
PsaParameterData inj1Data,
PsaParameterData inj2Data,
PsaParameterData inj3Data,
PsaParameterData inj4Data,
DateTime date)
{
GenerateMedianData(rpmData, inj1Data, 1, date);
GenerateMedianData(rpmData, inj2Data, 2, date);
GenerateMedianData(rpmData, inj3Data, 3, date);
GenerateMedianData(rpmData, inj4Data, 4, date);
GenerateRangeData(rpmData, inj1Data, 1, date);
GenerateRangeData(rpmData, inj2Data, 2, date);
GenerateRangeData(rpmData, inj3Data, 3, date);
GenerateRangeData(rpmData, inj4Data, 4, date);
}
private IList <int> ExtractRpmIndexes(
PsaParameterData rpmDataSet, int valueBase)
{
IList <int> result = new List <int>();
for (int i = 0; i < rpmDataSet.Values.Count; i++)
{
double value;
double.TryParse(rpmDataSet.Values[i], NumberStyles.Float,
CultureInfo.InvariantCulture, out value);
if (DeltaHelper.GetDeltaPercentage(value,
valueBase) <= RpmDifferencePercentage)
{
result.Add(i);
}
}
return(result);
}
/// <summary>
/// Deserialization
/// </summary>
/// <param name="paramSetElement"></param>
/// <param name="set"></param>
private void DeserializeParametersSet(XElement paramSetElement,
PsaParametersSet set)
{
set.PsaTraceId = long.Parse(paramSetElement.
Element(PsaTraceIdName).Value);
set.Type = (PsaParametersSetType)Int32.Parse(paramSetElement.
Element(TypeName).Value);
XElement parametersElement =
paramSetElement.Element(ParametersName);
IEnumerable <XElement> parameterElements =
parametersElement.Elements(ParameterName);
foreach (XElement element in parameterElements)
{
PsaParameterData data = DeserializeParameterData(element);
set.Parameters.Add(data);
}
}
private void UpdateSetWithScreenData(PsaParametersSet set,
PeugeotScreen screen)
{
foreach (PeugeotRawParameterPoint p in screen.Points)
{
// At first it was by type but an issue raised with unsupported data
/*PsaParameterData target = set.Parameters.FirstOrDefault(pr =>
* pr.Type == PeugeotParameterTypeConverter.Convert(p.ParameterName));*/
if (set.Parameters.Any(pt => String.IsNullOrEmpty(pt.OriginalName)))
{
throw new NotSupportedException();
}
PsaParameterData target = set.Parameters.FirstOrDefault(
pr => pr.OriginalName.Equals(p.ParameterName, StringComparison.OrdinalIgnoreCase));
target.Values.Add(p.Value);
}
}
/// <summary>
/// Deserialization
/// </summary>
/// <param name="parameterElement"></param>
private PsaParameterData DeserializeParameterData(XElement parameterElement)
{
ResourceManager mgr = new ResourceManager(
typeof(SerializationStrings));
string idNameResolved = mgr.GetString(IdName);
string hasTimestampsNameResolved = mgr.GetString(HasTimestampsName);
string sourceParamSetIdNameResolved = ParametersSetIdName;
//mgr.GetString(SourceParamSetIdName);
PsaParameterData data = new PsaParameterData(parameterElement.Element(OriginalTypeId).Value);
data.Id = long.Parse(parameterElement.Element(idNameResolved).Value);
data.HasTimestamps = Boolean.Parse(parameterElement.Element(hasTimestampsNameResolved).Value);
data.PsaParametersSetId = long.Parse(parameterElement.Element(sourceParamSetIdNameResolved).Value);
if (parameterElement.Element(OriginalTypeId) != null)
{
data.OriginalTypeId = parameterElement.Element(OriginalTypeId).Value;
}
if (parameterElement.Element(AdditionalSourceInfoName) != null)
{
data.AdditionalSourceInfo = parameterElement.Element(AdditionalSourceInfoName).Value;
}
data.Type = (PsaParameterType)
Int32.Parse(parameterElement.Element(TypeName).Value);
data.Units = (Unit)
Int32.Parse(parameterElement.Element(UnitsName).Value);
XElement valuesElement = parameterElement.Element(ValuesName);
foreach (XElement valueElement in valuesElement.Elements(ValueName))
{
data.Values.Add(valueElement.Value);
}
if (data.HasTimestamps)
{
XElement timestampsElement =
parameterElement.Element(TimestampsName);
foreach (XElement timestampElement in
timestampsElement.Elements(TimestampName))
{
data.Timestamps.Add(Int32.Parse(timestampElement.Value));
}
}
return(data);
}
private IList <double> ExtractStartupVoltageValues(PsaParameterData rpm,
PsaParameterData voltage)
{
IList <double> result = new List <double>();
EngineStartupDetector detector =
new EngineStartupDetector(rpm.GetDoubles());
if (detector.EngineStartupDetected())
{
IList <int> startupIndexes =
detector.GetEngineStartupPointIndexes();
IList <double> voltageValues = voltage.GetDoubles();
foreach (int index in startupIndexes)
{
result.Add(voltageValues[index]);
}
}
return(result);
}
/// <summary>
/// Deserialization
/// </summary>
/// <param name="paramSetElement"></param>
/// <param name="set"></param>
private void DeserializeParametersSet(XElement paramSetElement,
PsaParametersSet set)
{
ResourceManager mgr = new ResourceManager(
typeof(SerializationStrings));
set.PsaTraceId = long.Parse(paramSetElement.
Element(mgr.GetString(PsaTraceIdName)).Value);
set.Type = (PsaParametersSetType)Int32.Parse(paramSetElement.
Element(mgr.GetString(TypeName)).Value);
XElement parametersElement =
paramSetElement.Element(ParametersName);
IEnumerable <XElement> parameterElements =
parametersElement.Elements(ParameterName);
foreach (XElement element in parameterElements)
{
PsaParameterData data = DeserializeParameterData(element);
set.Parameters.Add(data);
}
}
private static PsaParameterData Convert(LexiaChannelRawData channel)
{
PsaParameterData parameter = new PsaParameterData(channel.Header.Mnemocode) // Passed original type id
{
HasTimestamps = true, // for Graph it is true
AdditionalSourceInfo =
GenerateAdditionalSourceInfo(channel.Header.Mnemocode),
Type = ConvertType(channel.Header.Mnemocode),
OriginalName = channel.Header.Mnemocode,
Units = UnitsConverter.Convert(channel.Header.DataUnit)
};
foreach (LexiaRawDataPoint p in channel.ChannelDataPoints.Points)
{
int ts;
Int32.TryParse(p.TimeStamp, NumberStyles.Integer,
CultureInfo.InvariantCulture, out ts);
parameter.Timestamps.Add(ts);
parameter.Values.Add(p.Value);
}
return(parameter);
}
public static PsaParameterData FromDtoToDomainObject(PsaParameterDataDto source)
{
PsaParameterData target = new PsaParameterData(source.OriginalTypeId);
target.Id = source.Id;
target.HasTimestamps = source.HasTimestamps;
target.PsaParametersSetId = source.PsaParametersSetId;
target.Type = (PsaParameterType)source.Type;
target.Units = (Unit)source.Units;
target.OriginalTypeId = source.OriginalTypeId;
//target.OriginalName = source.OriginalName;
foreach (int timestamp in source.Timestamps)
{
target.Timestamps.Add(timestamp);
}
foreach (string s in source.Values)
{
target.Values.Add(s);
}
target.AdditionalSourceInfo = source.AdditionalSourceInfo;
return(target);
}
