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));
}
