410 lines
20 KiB
C#
410 lines
20 KiB
C#
using Adaptation.Shared;
|
|
using Adaptation.Shared.Metrology;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text.Json;
|
|
|
|
namespace Adaptation.Helpers
|
|
{
|
|
|
|
public partial class ProcessData
|
|
{
|
|
|
|
public class FileRead
|
|
{
|
|
|
|
public class Description : IProcessDataDescription
|
|
{
|
|
|
|
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 GetEventDescription() { return "File Has been read and parsed"; }
|
|
|
|
public List<string> GetHeaderNames(ILogic logic, ConfigDataBase configDataBase)
|
|
{
|
|
List<string> results = new List<string>
|
|
{
|
|
nameof(Date),
|
|
nameof(Employee),
|
|
nameof(Lot),
|
|
nameof(PSN),
|
|
nameof(Reactor),
|
|
nameof(Recipe)
|
|
};
|
|
return results;
|
|
}
|
|
|
|
public List<string> GetDetailNames(ILogic logic, ConfigDataBase configDataBase)
|
|
{
|
|
List<string> results = new List<string>
|
|
{
|
|
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;
|
|
}
|
|
|
|
public List<string> GetParameterNames(ILogic logic, ConfigDataBase configDataBase)
|
|
{
|
|
List<string> results = new List<string>
|
|
{
|
|
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)
|
|
};
|
|
return results;
|
|
}
|
|
|
|
public List<string> GetPairedParameterNames(ILogic logic, ConfigDataBase configDataBase)
|
|
{
|
|
List<string> results = new List<string>();
|
|
return results;
|
|
}
|
|
|
|
public List<string> GetIgnoreParameterNames(ILogic logic, ConfigDataBase configDataBase, Test test)
|
|
{
|
|
List<string> results = new List<string>();
|
|
return results;
|
|
}
|
|
|
|
public List<string> GetNames(ILogic logic, ConfigDataBase configDataBase)
|
|
{
|
|
List<string> results = new List<string>();
|
|
IProcessDataDescription processDataDescription = GetDefault(logic, configDataBase);
|
|
string json = JsonSerializer.Serialize(processDataDescription, processDataDescription.GetType());
|
|
object @object = JsonSerializer.Deserialize<object>(json);
|
|
if (!(@object is JsonElement jsonElement))
|
|
throw new Exception();
|
|
foreach (JsonProperty jsonProperty in jsonElement.EnumerateObject())
|
|
results.Add(jsonProperty.Name);
|
|
return results;
|
|
}
|
|
|
|
public IProcessDataDescription GetDisplayNames(ILogic logic, ConfigDataBase configDataBase)
|
|
{
|
|
Description result = new Description();
|
|
return result;
|
|
}
|
|
|
|
public IProcessDataDescription GetDefault(ILogic logic, ConfigDataBase configDataBase)
|
|
{
|
|
Description result = new Description
|
|
{
|
|
Test = -1,
|
|
Count = 0,
|
|
Index = -1,
|
|
//
|
|
EventName = configDataBase.GetEventName(),
|
|
NullData = string.Empty,
|
|
JobID = logic.Logistics.JobID,
|
|
Sequence = logic.Logistics.Sequence.ToString(),
|
|
MesEntity = logic.Logistics.MesEntity,
|
|
ReportFullPath = logic.Logistics.ReportFullPath,
|
|
ProcessJobID = logic.Logistics.ProcessJobID,
|
|
MID = logic.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),
|
|
};
|
|
return result;
|
|
}
|
|
|
|
public List<IProcessDataDescription> GetDescription(ILogic logic, ConfigDataBase configDataBase, List<Test> tests, IProcessData iProcessData)
|
|
{
|
|
List<IProcessDataDescription> results = new List<IProcessDataDescription>();
|
|
if (iProcessData is null || !(iProcessData is ProcessData processData) || processData.Header is null || !processData.Details.Any())
|
|
results.Add(GetDefault(logic, configDataBase));
|
|
else
|
|
{
|
|
string nullData;
|
|
Description description;
|
|
object configDataNullData = ConfigData.NullData;
|
|
if (configDataNullData is null)
|
|
nullData = string.Empty;
|
|
else
|
|
nullData = configDataNullData.ToString();
|
|
for (int i = 0; i < processData.Details.Count; i++)
|
|
{
|
|
description = new Description
|
|
{
|
|
Test = (int)tests[i],
|
|
Count = tests.Count,
|
|
Index = i,
|
|
//
|
|
EventName = configDataBase.GetEventName(),
|
|
NullData = nullData,
|
|
JobID = logic.Logistics.JobID,
|
|
Sequence = logic.Logistics.Sequence.ToString(),
|
|
MesEntity = logic.Logistics.MesEntity,
|
|
ReportFullPath = logic.Logistics.ReportFullPath,
|
|
ProcessJobID = logic.Logistics.ProcessJobID,
|
|
MID = logic.Logistics.MID,
|
|
//
|
|
Date = processData.Header.Date,
|
|
Employee = processData.Header.Employee,
|
|
Lot = processData.Header.Lot,
|
|
PSN = processData.Header.PSN,
|
|
Reactor = processData.Header.Reactor,
|
|
Recipe = string.Empty,
|
|
//
|
|
Area = processData.Header.Area,
|
|
Folder = processData.Header.Folder,
|
|
HeaderUniqueId = processData.Details[i].HeaderUniqueId,
|
|
Id = string.Empty,
|
|
Layer = processData.Header.Layer,
|
|
Model = processData.Header.Model,
|
|
Pattern = processData.Header.Pattern,
|
|
Phase = processData.Details[i].Phase,
|
|
Plan = processData.Header.Plan,
|
|
RampRate = processData.Header.RampRate,
|
|
RDS = processData.Header.RDS,
|
|
SetupFile = processData.Header.SetupFile,
|
|
StartVoltage = processData.Header.StartVoltage,
|
|
StopVoltage = processData.Header.StopVoltage,
|
|
UniqueId = processData.Details[i].UniqueId,
|
|
Wafer = processData.Header.Wafer,
|
|
WaferSize = processData.Header.WaferSize,
|
|
Zone = processData.Header.Zone,
|
|
//
|
|
Ccomp = processData.Header.Ccomp,
|
|
CondType = processData.Header.CondType,
|
|
FlatZ = processData.Details[i].FlatZ,
|
|
FlatZMean = processData.Header.FlatZMean,
|
|
FlatZRadialGradient = processData.Header.FlatZRadialGradient,
|
|
FlatZStdDev = processData.Header.FlatZStdDev,
|
|
GLimit = processData.Header.GLimit,
|
|
Grade = processData.Details[i].Grade,
|
|
GradeMean = processData.Header.GradeMean,
|
|
GradeRadialGradient = processData.Header.GradeRadialGradient,
|
|
GradeStdDev = processData.Header.GradeStdDev,
|
|
NAvg = processData.Details[i].NAvg,
|
|
NAvgMean = processData.Header.NAvgMean,
|
|
NAvgRadialGradient = processData.Header.NAvgRadialGradient,
|
|
NAvgStdDev = processData.Header.NAvgStdDev,
|
|
Nsl = processData.Details[i].Nsl,
|
|
NslMean = processData.Header.NslMean,
|
|
NslRadialGradient = processData.Header.NslRadialGradient,
|
|
NslStdDev = processData.Header.NslStdDev,
|
|
PhaseMean = processData.Header.PhaseMean,
|
|
PhaseRadialGradient = processData.Header.PhaseRadialGradient,
|
|
PhaseStdDev = processData.Header.PhaseStdDev,
|
|
RhoAvg = processData.Details[i].RhoAvg,
|
|
RhoAvgMean = processData.Header.RhoAvgMean,
|
|
RhoAvgRadialGradient = processData.Header.RhoAvgRadialGradient,
|
|
RhoAvgStdDev = processData.Header.RhoAvgStdDev,
|
|
RhoMethod = processData.Header.RhoMethod,
|
|
Rhosl = processData.Details[i].Rhosl,
|
|
RhoslMean = processData.Header.RhoslMean,
|
|
RhoslRadialGradient = processData.Header.RhoslRadialGradient,
|
|
RhoslStdDev = processData.Header.RhoslStdDev,
|
|
RsMean = processData.Header.RsMean,
|
|
RsRadialGradient = processData.Header.RsRadialGradient,
|
|
RsStdDev = processData.Header.RsStdDev,
|
|
Vd = processData.Details[i].Vd,
|
|
VdMean = processData.Header.VdMean,
|
|
VdRadialGradient = processData.Header.VdRadialGradient,
|
|
VdStdDev = processData.Header.VdStdDev
|
|
};
|
|
results.Add(description);
|
|
}
|
|
}
|
|
return results;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} |