444 lines
16 KiB
C#
444 lines
16 KiB
C#
using Adaptation.Shared;
|
|
using Adaptation.Shared.Methods;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text.Json;
|
|
|
|
namespace Adaptation.FileHandlers.pcl;
|
|
|
|
public class Description : IDescription, Shared.Properties.IDescription
|
|
{
|
|
|
|
public int Test { get; set; }
|
|
public int Count { get; set; }
|
|
public int Index { get; set; }
|
|
//
|
|
public string EventName { get; set; }
|
|
public string NullData { get; set; }
|
|
public string JobID { get; set; }
|
|
public string Sequence { get; set; }
|
|
public string MesEntity { get; set; }
|
|
public string ReportFullPath { get; set; }
|
|
public string ProcessJobID { get; set; }
|
|
public string MID { get; set; }
|
|
//
|
|
public string Date { get; set; }
|
|
public string Employee { get; set; }
|
|
public string Lot { get; set; }
|
|
public string PSN { get; set; }
|
|
public string Reactor { get; set; }
|
|
public string Recipe { get; set; }
|
|
//
|
|
public string Area { get; set; }
|
|
public string Folder { get; set; }
|
|
public string HeaderUniqueId { get; set; }
|
|
public string Id { get; set; }
|
|
public string Layer { get; set; }
|
|
public string Model { get; set; }
|
|
public string Pattern { get; set; }
|
|
public string Phase { get; set; }
|
|
public string Plan { get; set; }
|
|
public string RampRate { get; set; }
|
|
public string RDS { get; set; }
|
|
public string SetupFile { get; set; }
|
|
public string StartVoltage { get; set; }
|
|
public string StopVoltage { get; set; }
|
|
public string UniqueId { get; set; }
|
|
public string Wafer { get; set; }
|
|
public string WaferSize { get; set; }
|
|
public string Zone { get; set; }
|
|
//
|
|
public string Ccomp { get; set; }
|
|
public string CondType { get; set; }
|
|
public string FlatZ { get; set; }
|
|
public string FlatZMean { get; set; }
|
|
public string FlatZRadialGradient { get; set; }
|
|
public string FlatZStdDev { get; set; }
|
|
public string GLimit { get; set; }
|
|
public string Grade { get; set; }
|
|
public string GradeMean { get; set; }
|
|
public string GradeRadialGradient { get; set; }
|
|
public string GradeStdDev { get; set; }
|
|
public string NAvg { get; set; }
|
|
public string NAvgMean { get; set; }
|
|
public string NAvgRadialGradient { get; set; }
|
|
public string NAvgStdDev { get; set; }
|
|
public string Nsl { get; set; }
|
|
public string NslMean { get; set; }
|
|
public string NslRadialGradient { get; set; }
|
|
public string NslStdDev { get; set; }
|
|
public string PhaseMean { get; set; }
|
|
public string PhaseRadialGradient { get; set; }
|
|
public string PhaseStdDev { get; set; }
|
|
public string RhoAvg { get; set; }
|
|
public string RhoAvgMean { get; set; }
|
|
public string RhoAvgRadialGradient { get; set; }
|
|
public string RhoAvgStdDev { get; set; }
|
|
public string RhoMethod { get; set; }
|
|
public string Rhosl { get; set; }
|
|
public string RhoslMean { get; set; }
|
|
public string RhoslRadialGradient { get; set; }
|
|
public string RhoslStdDev { get; set; }
|
|
public string RsMean { get; set; }
|
|
public string RsRadialGradient { get; set; }
|
|
public string RsStdDev { get; set; }
|
|
public string Vd { get; set; }
|
|
public string VdMean { get; set; }
|
|
public string VdRadialGradient { get; set; }
|
|
public string VdStdDev { get; set; }
|
|
//
|
|
public string Variation { get; set; }
|
|
|
|
string IDescription.GetEventDescription() => "File Has been read and parsed";
|
|
|
|
List<string> IDescription.GetNames(IFileRead fileRead, Logistics logistics)
|
|
{
|
|
List<string> results = new();
|
|
IDescription description = GetDefault(fileRead, logistics);
|
|
string json = JsonSerializer.Serialize(description, description.GetType());
|
|
object @object = JsonSerializer.Deserialize<object>(json);
|
|
if (@object is not JsonElement jsonElement)
|
|
throw new Exception();
|
|
foreach (JsonProperty jsonProperty in jsonElement.EnumerateObject())
|
|
results.Add(jsonProperty.Name);
|
|
return results;
|
|
}
|
|
|
|
List<string> IDescription.GetDetailNames()
|
|
{
|
|
List<string> results = new()
|
|
{
|
|
nameof(Area),
|
|
nameof(Folder),
|
|
nameof(HeaderUniqueId),
|
|
nameof(Id),
|
|
nameof(Layer),
|
|
nameof(Model),
|
|
nameof(Pattern),
|
|
nameof(Phase),
|
|
nameof(Plan),
|
|
nameof(RampRate),
|
|
nameof(RDS),
|
|
nameof(SetupFile),
|
|
nameof(StartVoltage),
|
|
nameof(StopVoltage),
|
|
nameof(UniqueId),
|
|
nameof(Wafer),
|
|
nameof(WaferSize),
|
|
nameof(Zone)
|
|
};
|
|
return results;
|
|
}
|
|
|
|
List<string> IDescription.GetHeaderNames()
|
|
{
|
|
List<string> results = new()
|
|
{
|
|
nameof(Date),
|
|
nameof(Employee),
|
|
nameof(Lot),
|
|
nameof(PSN),
|
|
nameof(Reactor),
|
|
nameof(Recipe)
|
|
};
|
|
return results;
|
|
}
|
|
|
|
IDescription IDescription.GetDisplayNames()
|
|
{
|
|
Description result = GetDisplayNames();
|
|
return result;
|
|
}
|
|
|
|
List<string> IDescription.GetParameterNames()
|
|
{
|
|
List<string> results = new()
|
|
{
|
|
nameof(Ccomp),
|
|
nameof(CondType),
|
|
nameof(FlatZ),
|
|
nameof(FlatZMean),
|
|
nameof(FlatZRadialGradient),
|
|
nameof(FlatZStdDev),
|
|
nameof(GLimit),
|
|
nameof(Grade),
|
|
nameof(GradeMean),
|
|
nameof(GradeRadialGradient),
|
|
nameof(GradeStdDev),
|
|
nameof(NAvg),
|
|
nameof(NAvgMean),
|
|
nameof(NAvgRadialGradient),
|
|
nameof(NAvgStdDev),
|
|
nameof(Nsl),
|
|
nameof(NslMean),
|
|
nameof(NslRadialGradient),
|
|
nameof(NslStdDev),
|
|
nameof(PhaseMean),
|
|
nameof(PhaseRadialGradient),
|
|
nameof(PhaseStdDev),
|
|
nameof(RhoAvg),
|
|
nameof(RhoAvgMean),
|
|
nameof(RhoAvgRadialGradient),
|
|
nameof(RhoAvgStdDev),
|
|
nameof(RhoMethod),
|
|
nameof(Rhosl),
|
|
nameof(RhoslMean),
|
|
nameof(RhoslRadialGradient),
|
|
nameof(RhoslStdDev),
|
|
nameof(RsMean),
|
|
nameof(RsRadialGradient),
|
|
nameof(RsStdDev),
|
|
nameof(Vd),
|
|
nameof(VdMean),
|
|
nameof(VdRadialGradient),
|
|
nameof(VdStdDev),
|
|
nameof(Variation),
|
|
};
|
|
return results;
|
|
}
|
|
|
|
JsonProperty[] IDescription.GetDefault(IFileRead fileRead, Logistics logistics)
|
|
{
|
|
JsonProperty[] results;
|
|
IDescription description = GetDefault(fileRead, logistics);
|
|
string json = JsonSerializer.Serialize(description, description.GetType());
|
|
object @object = JsonSerializer.Deserialize<object>(json);
|
|
results = ((JsonElement)@object).EnumerateObject().ToArray();
|
|
return results;
|
|
}
|
|
|
|
List<string> IDescription.GetPairedParameterNames()
|
|
{
|
|
List<string> results = new();
|
|
return results;
|
|
}
|
|
|
|
List<string> IDescription.GetIgnoreParameterNames(Test test)
|
|
{
|
|
List<string> results = new();
|
|
return results;
|
|
}
|
|
|
|
IDescription IDescription.GetDefaultDescription(IFileRead fileRead, Logistics logistics)
|
|
{
|
|
Description result = GetDefault(fileRead, logistics);
|
|
return result;
|
|
}
|
|
|
|
Dictionary<string, string> IDescription.GetDisplayNamesJsonElement(IFileRead fileRead)
|
|
{
|
|
Dictionary<string, string> results = new();
|
|
IDescription description = GetDisplayNames();
|
|
string json = JsonSerializer.Serialize(description, description.GetType());
|
|
JsonElement jsonElement = JsonSerializer.Deserialize<JsonElement>(json);
|
|
foreach (JsonProperty jsonProperty in jsonElement.EnumerateObject())
|
|
{
|
|
if (!results.ContainsKey(jsonProperty.Name))
|
|
results.Add(jsonProperty.Name, string.Empty);
|
|
if (jsonProperty.Value is JsonElement jsonPropertyValue)
|
|
results[jsonProperty.Name] = jsonPropertyValue.ToString();
|
|
}
|
|
return results;
|
|
}
|
|
|
|
List<IDescription> IDescription.GetDescriptions(IFileRead fileRead, Logistics logistics, List<Test> tests, IProcessData iProcessData)
|
|
{
|
|
List<IDescription> results = new();
|
|
if (iProcessData is null || !iProcessData.Details.Any() || iProcessData is not ProcessData processData)
|
|
results.Add(GetDefault(fileRead, logistics));
|
|
else
|
|
{
|
|
string nullData;
|
|
Description description;
|
|
object configDataNullData = fileRead.NullData;
|
|
if (configDataNullData is null)
|
|
nullData = string.Empty;
|
|
else
|
|
nullData = configDataNullData.ToString();
|
|
for (int i = 0; i < iProcessData.Details.Count; i++)
|
|
{
|
|
if (iProcessData.Details[i] is not Detail detail)
|
|
continue;
|
|
description = new Description
|
|
{
|
|
Test = (int)tests[i],
|
|
Count = tests.Count,
|
|
Index = i,
|
|
//
|
|
EventName = fileRead.EventName,
|
|
NullData = nullData,
|
|
JobID = fileRead.CellInstanceName,
|
|
Sequence = logistics.Sequence.ToString(),
|
|
MesEntity = logistics.MesEntity,
|
|
ReportFullPath = logistics.ReportFullPath,
|
|
ProcessJobID = logistics.ProcessJobID,
|
|
MID = logistics.MID,
|
|
//
|
|
Date = processData.Date.ToString(GetDateFormat()),
|
|
Employee = processData.Employee,
|
|
Lot = processData.Lot,
|
|
PSN = processData.PSN,
|
|
Reactor = processData.Reactor,
|
|
Recipe = string.Empty,
|
|
//
|
|
Area = processData.Area,
|
|
Folder = processData.Folder,
|
|
HeaderUniqueId = detail.UniqueId,
|
|
Id = string.Empty,
|
|
Layer = processData.Layer,
|
|
Model = processData.Model,
|
|
Pattern = processData.Pattern,
|
|
Phase = detail.Phase,
|
|
Plan = processData.Plan,
|
|
RampRate = processData.RampRate,
|
|
RDS = processData.RDS,
|
|
SetupFile = processData.SetupFile,
|
|
StartVoltage = processData.StartVoltage,
|
|
StopVoltage = processData.StopVoltage,
|
|
UniqueId = detail.UniqueId,
|
|
Wafer = processData.Wafer,
|
|
WaferSize = processData.WaferSize,
|
|
Zone = processData.Zone,
|
|
//
|
|
Ccomp = processData.Ccomp,
|
|
CondType = processData.CondType,
|
|
FlatZ = detail.FlatZ,
|
|
FlatZMean = processData.FlatZMean,
|
|
FlatZRadialGradient = processData.FlatZRadialGradient,
|
|
FlatZStdDev = processData.FlatZStdDev,
|
|
GLimit = processData.GLimit,
|
|
Grade = detail.Grade,
|
|
GradeMean = processData.GradeMean,
|
|
GradeRadialGradient = processData.GradeRadialGradient,
|
|
GradeStdDev = processData.GradeStdDev,
|
|
NAvg = detail.NAvg,
|
|
NAvgMean = processData.NAvgMean,
|
|
NAvgRadialGradient = processData.NAvgRadialGradient,
|
|
NAvgStdDev = processData.NAvgStdDev,
|
|
Nsl = detail.Nsl,
|
|
NslMean = processData.NslMean,
|
|
NslRadialGradient = processData.NslRadialGradient,
|
|
NslStdDev = processData.NslStdDev,
|
|
PhaseMean = processData.PhaseMean,
|
|
PhaseRadialGradient = processData.PhaseRadialGradient,
|
|
PhaseStdDev = processData.PhaseStdDev,
|
|
RhoAvg = detail.RhoAvg,
|
|
RhoAvgMean = processData.RhoAvgMean,
|
|
RhoAvgRadialGradient = processData.RhoAvgRadialGradient,
|
|
RhoAvgStdDev = processData.RhoAvgStdDev,
|
|
RhoMethod = processData.RhoMethod,
|
|
Rhosl = detail.Rhosl,
|
|
RhoslMean = processData.RhoslMean,
|
|
RhoslRadialGradient = processData.RhoslRadialGradient,
|
|
RhoslStdDev = processData.RhoslStdDev,
|
|
RsMean = processData.RsMean,
|
|
RsRadialGradient = processData.RsRadialGradient,
|
|
RsStdDev = processData.RsStdDev,
|
|
Vd = detail.Vd,
|
|
VdMean = processData.VdMean,
|
|
VdRadialGradient = processData.VdRadialGradient,
|
|
VdStdDev = processData.VdStdDev,
|
|
Variation = string.Empty,
|
|
};
|
|
results.Add(description);
|
|
}
|
|
}
|
|
return results;
|
|
}
|
|
|
|
private static Description GetDisplayNames()
|
|
{
|
|
Description result = new();
|
|
return result;
|
|
}
|
|
|
|
private Description GetDefault(IFileRead fileRead, Logistics logistics)
|
|
{
|
|
Description result = new()
|
|
{
|
|
Test = -1,
|
|
Count = 0,
|
|
Index = -1,
|
|
//
|
|
EventName = fileRead.EventName,
|
|
NullData = fileRead.NullData,
|
|
JobID = fileRead.CellInstanceName,
|
|
Sequence = logistics.Sequence.ToString(),
|
|
MesEntity = fileRead.MesEntity,
|
|
ReportFullPath = logistics.ReportFullPath,
|
|
ProcessJobID = logistics.ProcessJobID,
|
|
MID = logistics.MID,
|
|
//
|
|
Date = nameof(Date),
|
|
Employee = nameof(Employee),
|
|
Lot = nameof(Lot),
|
|
PSN = nameof(PSN),
|
|
Reactor = nameof(Reactor),
|
|
Recipe = nameof(Recipe),
|
|
//
|
|
Area = nameof(Area),
|
|
Folder = nameof(Folder),
|
|
HeaderUniqueId = nameof(HeaderUniqueId),
|
|
Id = nameof(Id),
|
|
Layer = nameof(Layer),
|
|
Model = nameof(Model),
|
|
Pattern = nameof(Pattern),
|
|
Phase = nameof(Phase),
|
|
Plan = nameof(Plan),
|
|
RampRate = nameof(RampRate),
|
|
RDS = nameof(RDS),
|
|
SetupFile = nameof(SetupFile),
|
|
StartVoltage = nameof(StartVoltage),
|
|
StopVoltage = nameof(StopVoltage),
|
|
UniqueId = nameof(UniqueId),
|
|
Wafer = nameof(Wafer),
|
|
WaferSize = nameof(WaferSize),
|
|
Zone = nameof(Zone),
|
|
//
|
|
Ccomp = nameof(Ccomp),
|
|
CondType = nameof(CondType),
|
|
FlatZ = nameof(FlatZ),
|
|
FlatZMean = nameof(FlatZMean),
|
|
FlatZRadialGradient = nameof(FlatZRadialGradient),
|
|
FlatZStdDev = nameof(FlatZStdDev),
|
|
GLimit = nameof(GLimit),
|
|
Grade = nameof(Grade),
|
|
GradeMean = nameof(GradeMean),
|
|
GradeRadialGradient = nameof(GradeRadialGradient),
|
|
GradeStdDev = nameof(GradeStdDev),
|
|
NAvg = nameof(NAvg),
|
|
NAvgMean = nameof(NAvgMean),
|
|
NAvgRadialGradient = nameof(NAvgRadialGradient),
|
|
NAvgStdDev = nameof(NAvgStdDev),
|
|
Nsl = nameof(Nsl),
|
|
NslMean = nameof(NslMean),
|
|
NslRadialGradient = nameof(NslRadialGradient),
|
|
NslStdDev = nameof(NslStdDev),
|
|
PhaseMean = nameof(PhaseMean),
|
|
PhaseRadialGradient = nameof(PhaseRadialGradient),
|
|
PhaseStdDev = nameof(PhaseStdDev),
|
|
RhoAvg = nameof(RhoAvg),
|
|
RhoAvgMean = nameof(RhoAvgMean),
|
|
RhoAvgRadialGradient = nameof(RhoAvgRadialGradient),
|
|
RhoAvgStdDev = nameof(RhoAvgStdDev),
|
|
RhoMethod = nameof(RhoMethod),
|
|
Rhosl = nameof(Rhosl),
|
|
RhoslMean = nameof(RhoslMean),
|
|
RhoslRadialGradient = nameof(RhoslRadialGradient),
|
|
RhoslStdDev = nameof(RhoslStdDev),
|
|
RsMean = nameof(RsMean),
|
|
RsRadialGradient = nameof(RsRadialGradient),
|
|
RsStdDev = nameof(RsStdDev),
|
|
Vd = nameof(Vd),
|
|
VdMean = nameof(VdMean),
|
|
VdRadialGradient = nameof(VdRadialGradient),
|
|
VdStdDev = nameof(VdStdDev),
|
|
Variation = nameof(Variation),
|
|
};
|
|
return result;
|
|
}
|
|
|
|
internal static string GetDateFormat() => "MM/dd/yyyy hh:mm:ss tt";
|
|
|
|
} |