public ConditionEvaluationResultBase(DateTime creationTime, ICondition condition, IReferenceValue referenceValue, bool conditionIsMet, ICalculationResult calculationResult) : base(creationTime, calculationResult.Successful) { Condition = condition; ReferenceValue = referenceValue; ConditionIsMet = conditionIsMet; CalculationResult = calculationResult; }
public ReferenceValueObjectBaseCore(IReferenceValue builtFrom, IIdentifiableRetrievalManager retrievalManager) : base(builtFrom) { this.builtFrom = builtFrom; if (builtFrom.IdentifiableReference != null) { identifiableReference = retrievalManager.GetIdentifiableObject(builtFrom.GetIdentifiableReference()); } if (builtFrom.ContentConstraintReference != null) { contentConstraintReference = retrievalManager.GetIdentifiableObject<IContentConstraintObject>( builtFrom.ContentConstraintReference, typeof(IContentConstraintObject)); } }
public SimpleConditionEvaluationResult(DateTime creationTime, ICondition condition, IReferenceValue referenceValue, bool conditionIsMet, ICalculationResult calculationResult) : base(creationTime, condition, referenceValue, conditionIsMet, calculationResult) { }
protected abstract ICalculationResult InternalCalculation(IMeasurementSerie measurementSerieData, ICondition condition, IReferenceValue referenceValue);
public ICalculationResult Calculate(IMeasurementSerie measurementSerieData, ICondition condition, IReferenceValue referenceValue) { if (measurementSerieData?.MeasuredPoints == null) { _parameters.Logger.LogError("Received measdata is null."); return(null); } try { if (condition.CalculationTypeHandler.CalculationType != CalculationType) { throw new ArgumentException($"The current calculation (type: {CalculationType}) can not run with the received condition {condition.CalculationTypeHandler}"); } return(InternalCalculation(measurementSerieData, condition, referenceValue)); } catch (Exception ex) { _parameters.Logger.LogError($"Exception occured:{ex.Message}"); return(null); } }
protected override ICalculationResult InternalCalculation(IMeasurementSerie measurementSerieData, ICondition condition, IReferenceValue referenceValue) { List <double> validElementList = GetValidElementList(measurementSerieData); double average = GetAverage(validElementList); _parameters.Logger.LogTrace($"{nameof(AverageCalculation1D)}: Calculated average: {average}."); return(new SimpleCalculationResult(_parameters.DateTimeProvider.GetDateTime(), true, measurementSerieData, average, average)); }
private void Evaluate(QueueElement element) { IDataCollectorResult collectedData = element.DataCollectorResult; IToolSpecification specification = collectedData.Specification; IReadOnlyList <IToolMeasurementData> measurementDatas = collectedData.MeasurementData; IReferenceSample referenceSample = collectedData.Reference; if (specification == null) { _parameters.Logger.LogMethodError("Received specification is null."); return; } if (measurementDatas == null) { _parameters.Logger.LogMethodError("Received measurement data is null."); return; } _parameters.Logger.LogMethodInfo($"Started to evaluate received collectordata: Specification name: {specification.Name}"); _parameters.Logger.LogMethodInfo($"Reference name: {referenceSample?.Name ?? "No reference received"}."); _parameters.Logger.LogMethodInfo($"Measurement datas: {string.Join(",", measurementDatas.Select(p => p.Name))}"); List <IQuantityEvaluationResult> quantityResultList = new List <IQuantityEvaluationResult>(); // go through all quantity specifications: foreach (IQuantitySpecification quantitySpec in specification.QuantitySpecifications) { List <IConditionEvaluationResult> conditionResultList = new List <IConditionEvaluationResult>(quantitySpec.Conditions.Count); // go through all conditions in one quantity specification foreach (ICondition condition in quantitySpec.Conditions) { try { // skip condition if condition is null: //if (condition == null) //{ // _parameters.Logger.LogMethodError("Received condition is null"); // continue; //} _parameters.MessageControl.AddMessage(_parameters.Logger.LogMethodInfo($"{quantitySpec.Quantity.Name}-{condition.Name} Evaluation started.")); // skip condition if not enabled: if (!condition.Enabled) { _parameters.MessageControl.AddMessage(_parameters.Logger.LogMethodInfo($"{quantitySpec.Quantity.Name}-{condition.Name} is not enabled -> condition check skipped.")); continue; } // get the calculation: ICalculation calculation = _parameters.CalculationContainer.GetCalculation(condition.CalculationTypeHandler.CalculationType); // find measurement data associated with the condition name from the matcher: IEnumerable <string> coherentMeasurementDataNames = _parameters.Matcher.GetMeasDataNames(condition.Name); List <IMeasurementSerie> coherentMeasurementData = new List <IMeasurementSerie>(); foreach (var item in measurementDatas) { coherentMeasurementData.AddRange(item.Results.Where(p => coherentMeasurementDataNames.Contains(p.Name))); } if (coherentMeasurementData.Count == 0) { _parameters.MessageControl.AddMessage(_parameters.Logger.LogMethodError($"{quantitySpec.Quantity.Name}-{condition.Name} No coherent measurement data was found in measurement data files. Searched names: {string.Join(",", coherentMeasurementDataNames)}"), MessageSeverityLevels.Error); continue; } // if more result were found with the same name -> they will be linked together, unless their name is different the coherent measurement datas will be summarized into one measurement data List <INumericMeasurementPoint> measPointList = new List <INumericMeasurementPoint>(); foreach (IMeasurementSerie serie in coherentMeasurementData) { measPointList.AddRange(serie.MeasuredPoints); } IMeasurementSerie jointCalculationInputData = new MeasurementSerie(coherentMeasurementData[0].Name, measPointList, coherentMeasurementData[0].Dimension); _parameters.MessageControl.AddMessage(_parameters.Logger.LogMethodInfo($"{coherentMeasurementData.Count} measurement data(s) were created (joint together).")); // find reference associated with the specification string referenceName = _parameters.Matcher.GetReferenceName(condition.Name); IReferenceValue referenceValue = referenceSample?.ReferenceValues?.FirstOrDefault(p => string.Equals(p.Name, referenceName)); // perform calculation: IResult calcResult = calculation.Calculate(jointCalculationInputData, condition, referenceValue); if (!calcResult.Successful) { _parameters.MessageControl.AddMessage(_parameters.Logger.LogMethodError($"{quantitySpec.Quantity.Name}-{condition.Name} Calculation {calculation.CalculationType} was not successful."), MessageSeverityLevels.Error); continue; } IConditionEvaluationResult conditionEvaluationResult = condition.EvaluateCondition(calcResult, _parameters.DateTimeProvider.GetDateTime(), referenceValue); conditionResultList.Add(conditionEvaluationResult); #region logging if (_parameters.Logger.IsTraceEnabled) { _parameters.Logger.LogMethodTrace("The evaluation result:"); _parameters.Logger.LogMethodTrace($" End time: {conditionEvaluationResult.CreationTime}"); _parameters.Logger.LogMethodTrace($" The calculation was {(conditionEvaluationResult.Successful ? "" : "NOT")} successful."); _parameters.Logger.LogMethodTrace($" Calculation input data name {jointCalculationInputData.Name} number of measurement points: {jointCalculationInputData.MeasuredPoints.Count}"); _parameters.Logger.LogMethodTrace($" ReferenceValue: {referenceValue}"); _parameters.Logger.LogMethodTrace($" Condition: {condition}"); _parameters.Logger.LogMethodTrace($" The result is {(conditionEvaluationResult.ConditionIsMet ? "" : "NOT")} acceptable."); } #endregion } catch (Exception ex) { _parameters.Logger.LogMethodError($"Exception occured: {ex}"); } } quantityResultList.Add(new QuantityEvaluationResult(conditionResultList, quantitySpec.Quantity)); } IEvaluationResult evaluationResult = new EvaluationResult(_parameters.DateTimeProvider.GetDateTime(), true, quantityResultList, specification.ToolName, specification.Name); var resultreadyevent = ResultReadyEvent; resultreadyevent?.Invoke(this, new ResultEventArgs(evaluationResult)); _parameters.MessageControl.AddMessage(_parameters.Logger.LogMethodError("Calculation Finished")); }
protected override ICalculationResult InternalCalculation(IMeasurementSerie measurementSerieData, ICondition condition, IReferenceValue referenceValue) { if (!(condition is ICpkCondition cpkCondition)) { _parameters.Logger.Error($"No {nameof(cpkCondition)} condition received for settings creation."); return(null); } if (!(referenceValue is IReferenceValue <double>)) { throw new ArgumentException($"The received reference value is not {nameof(IReferenceValue<double>)}"); } List <double> validElementList = GetValidElementList(measurementSerieData); double average = GetAverage(validElementList); double std = GetStandardDeviation(validElementList, average); double usl = average + cpkCondition.HalfTolerance; double lsl = average - cpkCondition.HalfTolerance; double cp = (usl - lsl) / (6 * std); _parameters.Logger.LogMethodTrace($"{nameof(StdCalculation1D)}: Calculated Cp: {cp}, USL: {usl}, LSL: {lsl}, average: {average}"); return(new QCellsCalculationResult(_parameters.DateTimeProvider.GetDateTime(), true, measurementSerieData, cp, usl, lsl, average)); }
/////////////////////////////////////////////////////////////////////////////////////////////////// ////////////BUILD FROM V2.1 SCHEMA ////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////// #region Constructors and Destructors /// <summary> /// Initializes a new instance of the <see cref="DataKeyObjectCore"/> class. /// </summary> /// <param name="parent"> /// The parent. /// </param> /// <param name="type"> /// The type. /// </param> public DataKeyObjectCore(IReferenceValue parent, ComponentValueSetType type) : base(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.KeyValues), parent) { this.included = type.include; this.keyValue = new KeyValueImpl(type.Value[0].TypedValue, type.id); }
protected override ICalculationResult InternalCalculation(IMeasurementSerie measurementSerieData, ICondition condition, IReferenceValue referenceValue) { List <double> validElementList = measurementSerieData.MeasuredPoints.Where(p => p.Valid).Select(p => p.Value).ToList(); double average = GetAverage(validElementList); double std = GetStandardDeviation(validElementList, average); _parameters.Logger.LogTrace($"{nameof(StdCalculation1D)}: Calculated standard devaition: {std}, average: {average}"); return(new SimpleCalculationResult(_parameters.DateTimeProvider.GetDateTime(), true, measurementSerieData, std, average)); }
protected abstract IConditionEvaluationResult InternalEvaluate(IResult calculationResult, DateTime dateTimeProvider, IReferenceValue referenceValue);
public IConditionEvaluationResult EvaluateCondition(IResult calculationResult, DateTime dateTime, IReferenceValue referenceValue) { return(InternalEvaluate(calculationResult, dateTime, referenceValue)); }
protected override ICalculationResult InternalCalculation(IMeasurementSerie measurementSerieData, ICondition condition, IReferenceValue referenceValue) { if (!(condition is ICpkCondition cpkCondition)) { throw new ArgumentNullException($"No {nameof(ICpkCondition)} condition received for {CalculationType} settings creation."); } // CpkCalculation changes into CpCalculation if (referenceValue == null) { return(base.InternalCalculation(measurementSerieData, condition, null)); } if (!(referenceValue is IReferenceValue <double> doubleReferenceValue)) { throw new ArgumentException($"The received reference value is not {nameof(IReferenceValue<double>)}"); } List <double> validElementList = GetValidElementList(measurementSerieData); double average = GetAverage(validElementList); double std = GetStandardDeviation(validElementList, average); double usl = doubleReferenceValue.Value + cpkCondition.HalfTolerance; double lsl = doubleReferenceValue.Value - cpkCondition.HalfTolerance; double cpk = Math.Min((average - usl) / (3 * std), (lsl - average) / (3 * std)); _parameters.Logger.LogMethodTrace($"{nameof(StdCalculation1D)}: Calculated Cp: {cpk}, USL: {usl}, LSL: {lsl}, average:{average}"); return(new QCellsCalculationResult(_parameters.DateTimeProvider.GetDateTime(), true, measurementSerieData, cpk, usl, lsl, average)); }
protected override IConditionEvaluationResult InternalEvaluate(IResult result, DateTime dateTime, IReferenceValue referenceValue) { ISimpleCalculationResult calculationResult = result as ISimpleCalculationResult; return(CompareValidity(calculationResult.Average) ? new ConditionEvaluationResultBase(dateTime, this, referenceValue, EvaluateRelation(calculationResult.ResultValue), calculationResult) : null); }
protected override IConditionEvaluationResult InternalEvaluate(IResult result, DateTime dateTime, IReferenceValue referenceValue) { IQCellsCalculationResult qcellsResult = result as IQCellsCalculationResult; bool isMet = EvaluateRelation(qcellsResult.ResultValue); return(new ConditionEvaluationResultBase(dateTime, this, referenceValue, isMet, qcellsResult)); }