public AnalyticRuleCylinderCoilChargeTimeForRpm(
AnalyticRuleSettings settings)
: base(settings)
{
cylNumber = CylinderNumberToCoilRuleTypeMapper.Map(settings.RuleType);
requiredParameter = ModelRelatedPsaParameters.Get(cylNumber);
RegisterRequiredParameter(PsaParameterType.EngineRpm);
RegisterRequiredParameter(ModelRelatedPsaParameters.Get(
CylinderNumberToCoilRuleTypeMapper.Map(settings.RuleType)));
}
private void UpdateAnalyticRuleStatisticalAtomEntity(
AnalyticRuleSettings source, AnalyticRuleSettings target)
{
SettingsAtom atom = target.SettingsMolecule.First().SettingsAtom.First(a => a.Type == (int)SettingsAtomType.Statistical);
atom.MaxAcceptable = source.SettingsMolecule.First().SettingsAtom.First(a => a.Type == (int)SettingsAtomType.Statistical).MaxAcceptable;
atom.MinAcceptable = source.SettingsMolecule.First().SettingsAtom.First(a => a.Type == (int)SettingsAtomType.Statistical).MinAcceptable;
atom.MaxOptimal = source.SettingsMolecule.First().SettingsAtom.First(a => a.Type == (int)SettingsAtomType.Statistical).MaxOptimal;
atom.MinOptimal = source.SettingsMolecule.First().SettingsAtom.First(a => a.Type == (int)SettingsAtomType.Statistical).MinOptimal;
target.Reliability = source.Reliability;
}
private void SingleFetchedCallback(AnalyticRuleSettings item)
{
if (item != null)
{
alreadyExistsCallback.Invoke();
}
else
{
PersistItem(settingsToCreate);
}
}
public AnalyticRuleUpperLamdaProbeVoltageForRpm(
AnalyticRuleSettings settings)
: base(settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
RegisterRequiredParameter(PsaParameterType.EngineRpm);
RegisterRequiredParameter(PsaParameterType.UpperOxygenSensorVoltage);
}
public RuleEvaluationChronology(AnalyticRuleSettings ruleSettings,
List <AnalyticStatisticsValue> values)
{
if (values == null)
{
throw new ArgumentException("values");
}
this.ruleSettings = ruleSettings;
this.values = values;
EvaluateValues();
}
public static AnalyticRuleSettings FromDtoToDomainObject(AnalyticRuleSettingsDto source)
{
AnalyticRuleSettings target = new AnalyticRuleSettings(
(AnalyticRuleType)source.RuleType,
(AnalyticItemSettingsReliability)source.Reliability);
target.Id = source.Id;
target.EngineFamilyType = source.EngineFamilyType == null ? new Nullable <EngineFamilyType>() : (EngineFamilyType)source.EngineFamilyType;
target.EngineType = source.EngineType == null ? new Nullable <EngineType>() : (EngineType)source.EngineType;
target.SettingsMolecule = SettingsMoleculeAssembler.FromDtoToDomainObject(source.SettingsMolecule);
return(target);
}
public AnalyticModelElectricSystem(AnalyticModelSettingsElectricSystem settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
this.settings = settings;
AnalyticRuleSettings setting = settings.RulesSettings.
FirstOrDefault(r => r.RuleType == AnalyticRuleType.EngineStartUndervoltage);
Rules.Add(new AnalyticRuleStartupUndervoltage(setting));
}
public static AnalyticRuleSettingsEntity FromDomainObjectToEntity(AnalyticRuleSettings source)
{
AnalyticRuleSettingsEntity target = new AnalyticRuleSettingsEntity();
target.Id = source.Id;
target.EngineFamilyType = source.EngineFamilyType == null ? new int?() : (int)source.EngineFamilyType;
target.EngineType = source.EngineType == null ? new int?() : (int)source.EngineType;
target.Reliability = (int)source.Reliability;
target.RuleType = (int)source.RuleType;
target.SettingsMolecule.Add(SettingsMoleculeAssembler.FromDomainObjectToEntity(source.SettingsMolecule));
return(target);
}
public AnalyticModelCylinderCoilChargeTime(int cylNumber,
IList <AnalyticRuleSettings> rules)
{
this.cylNumber = cylNumber;
AnalyticRuleSettings rpm1000Settings = GetSettings(cylNumber, CheckpointRpm.Rpm1000, rules);
AnalyticRuleSettings rpm2000Settings = GetSettings(cylNumber, CheckpointRpm.Rpm2000, rules);
AnalyticRuleSettings rpm3000Settings = GetSettings(cylNumber, CheckpointRpm.Rpm3000, rules);
Rules.Add(new AnalyticRuleCylinderCoilChargeTimeForRpm(rpm1000Settings));
Rules.Add(new AnalyticRuleCylinderCoilChargeTimeForRpm(rpm2000Settings));
Rules.Add(new AnalyticRuleCylinderCoilChargeTimeForRpm(rpm3000Settings));
}
private void ButtonCreateClick(object sender, RoutedEventArgs e)
{
AnalyticRuleSettings settings = new AnalyticRuleSettings(
AnalyticRuleType.EngineStartUndervoltage,
AnalyticItemSettingsReliability.Unknown);
AnalyticRuleSettingsViewModel viewModel =
new AnalyticRuleSettingsViewModel(settings);
AnalyticRuleSettingsCreationWindow creationWindow =
new AnalyticRuleSettingsCreationWindow(viewModel);
creationWindow.Closed += DialogWindowStatus.OnDialogClosed;
creationWindow.Show();
}
public AnalyticModelFuelPressureRegulatorCurrent(
IList <AnalyticRuleSettings> rulesSettings)
{
AnalyticRuleSettings for1000 = rulesSettings.First(r =>
r.RuleType == AnalyticRuleType.FuelPressureRegulatorCurrent1000Rpm);
AnalyticRuleSettings for2000 = rulesSettings.First(r =>
r.RuleType == AnalyticRuleType.FuelPressureRegulatorCurrent2000Rpm);
AnalyticRuleSettings for3000 = rulesSettings.First(r =>
r.RuleType == AnalyticRuleType.FuelPressureRegulatorCurrent3000Rpm);
Rules.Add(new AnalyticRuleFuelRegulatorCurrentForRpm(for1000));
Rules.Add(new AnalyticRuleFuelRegulatorCurrentForRpm(for2000));
Rules.Add(new AnalyticRuleFuelRegulatorCurrentForRpm(for3000));
}
public AnalyticModelFuelPressureDelta(
IList <AnalyticRuleSettings> rulesSettings)
{
AnalyticRuleSettings for1000 = rulesSettings.First(r =>
r.RuleType == AnalyticRuleType.FuelPressureDelta1000Rpm);
AnalyticRuleSettings for2000 = rulesSettings.First(r =>
r.RuleType == AnalyticRuleType.FuelPressureDelta2000Rpm);
AnalyticRuleSettings for3000 = rulesSettings.First(r =>
r.RuleType == AnalyticRuleType.FuelPressureDelta3000Rpm);
Rules.Add(new AnalyticRuleFuelPressureDeltaForRpm(for1000));
Rules.Add(new AnalyticRuleFuelPressureDeltaForRpm(for2000));
Rules.Add(new AnalyticRuleFuelPressureDeltaForRpm(for3000));
}
public AnalyticRuleInjectorCorrection(AnalyticRuleSettings settings,
int injectorNumber)
: base(settings)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
this.settings = settings;
this.injectorNumber = injectorNumber;
RegisterRequiredParameter(PsaParameterType.EngineRpm);
RegisterRequiredParameter(PsaParameterType.Injector1Correction);
RegisterRequiredParameter(PsaParameterType.Injector2Correction);
RegisterRequiredParameter(PsaParameterType.Injector3Correction);
RegisterRequiredParameter(PsaParameterType.Injector4Correction);
}
public AnalyticRuleSettingsViewModel(AnalyticRuleSettings model)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
this.model = model;
type = new AnalyticRuleTypeViewModel(model.RuleType);
if (model.EngineFamilyType != null)
{
engineFamilyType =
new EngineFamilyTypeViewModel(model.EngineFamilyType.Value);
}
if (model.EngineType != null)
{
engineType = new EngineTypeViewModel(model.EngineType.Value);
}
}
public static IAnalyticRuleSettingsApplier CreateFor(AnalyticRuleSettings settings)
{
switch (settings.RuleType)
{
case AnalyticRuleType.Injector1CorrectionAt1000Rpm:
case AnalyticRuleType.Injector1CorrectionAt2000Rpm:
case AnalyticRuleType.Injector1CorrectionAt3000Rpm:
case AnalyticRuleType.Injector2CorrectionAt1000Rpm:
case AnalyticRuleType.Injector2CorrectionAt2000Rpm:
case AnalyticRuleType.Injector2CorrectionAt3000Rpm:
case AnalyticRuleType.Injector3CorrectionAt1000Rpm:
case AnalyticRuleType.Injector3CorrectionAt2000Rpm:
case AnalyticRuleType.Injector3CorrectionAt3000Rpm:
case AnalyticRuleType.Injector4CorrectionAt1000Rpm:
case AnalyticRuleType.Injector4CorrectionAt2000Rpm:
case AnalyticRuleType.Injector4CorrectionAt3000Rpm:
return(new AnalyticRuleSettingsApplierByAbsoluteValue(settings));
default:
return(new AnalyticRuleSettingsApplierDefault(settings));
}
}
public AnalyticModelLowerLambdaProbe(IList <AnalyticRuleSettings> rulesSettings)
{
AnalyticRuleSettings rpm1000Settings =
rulesSettings.FirstOrDefault(rs =>
rs.RuleType == AnalyticRuleType.LambdaLowerVoltageAt1000Rpm);
AnalyticRuleSettings rpm2000Settings =
rulesSettings.FirstOrDefault(rs =>
rs.RuleType == AnalyticRuleType.LambdaLowerVoltageAt2000Rpm);
AnalyticRuleSettings rpm3000Settings =
rulesSettings.FirstOrDefault(rs =>
rs.RuleType == AnalyticRuleType.LambdaLowerVoltageAt3000Rpm);
if (rpm1000Settings == null || rpm2000Settings == null || rpm3000Settings == null)
{
throw new Exception("Insufficient rules!");
}
Rules.Add(new AnalyticRuleLowerLamdaProbeVoltageForRpm(
rpm1000Settings));
Rules.Add(new AnalyticRuleLowerLamdaProbeVoltageForRpm(
rpm2000Settings));
Rules.Add(new AnalyticRuleLowerLamdaProbeVoltageForRpm(
rpm3000Settings));
}
public AnalyticRuleSettingsApplierDefault(AnalyticRuleSettings settings)
{
this.settings = settings;
atom = settings.SettingsMolecule.GetPriorityAtom();
}
public AnalyticRuleFuelPressureDeltaForRpm(AnalyticRuleSettings settings)
: base(settings)
{
RegisterRequiredParameter(PsaParameterType.EngineRpm);
RegisterRequiredParameter(PsaParameterType.FuelSystemPressureDelta);
}
public AnalyticRuleSettingsApplierByAbsoluteValue(AnalyticRuleSettings settings)
{
this.settings = settings;
atom = settings.SettingsMolecule.GetPriorityAtom();
}
protected AnalyticRuleBase(AnalyticRuleSettings settings)
{
this.settings = settings;
}
public AnalyticRuleLambdaProbeVoltageForRpmBase(
AnalyticRuleSettings settings)
: base(settings)
{
}
