924 lines
39 KiB
C#
924 lines
39 KiB
C#
using Adaptation.Shared;
|
|
using Adaptation.Shared.Methods;
|
|
using log4net;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text.Json;
|
|
using System.Text.Json.Serialization;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace Adaptation.FileHandlers.txt;
|
|
|
|
public class ProcessData : IProcessData
|
|
{
|
|
|
|
private int _I;
|
|
private string _Data;
|
|
|
|
private readonly ILog _Log;
|
|
private readonly List<object> _Details;
|
|
|
|
public string JobID { get; set; }
|
|
public string MesEntity { get; set; }
|
|
public string Date { get; set; }
|
|
public string Lot { get; set; }
|
|
public string Operator { get; set; }
|
|
public string PSN { get; set; }
|
|
public string RDS { get; set; }
|
|
public string Reactor { get; set; }
|
|
public string Recipe { get; set; }
|
|
public string Session { get; set; }
|
|
public string UniqueID { get; set; }
|
|
public string DcnAllMax { get; set; }
|
|
public string DcnAllMean { get; set; }
|
|
public string DcnAllMin { get; set; }
|
|
public string DcnAllStdDev { get; set; }
|
|
public string DcnAreaCountMax { get; set; }
|
|
public string DcnAreaCountMean { get; set; }
|
|
public string DcnAreaCountMin { get; set; }
|
|
public string DcnAreaCountStdDev { get; set; }
|
|
public string DcnAreaMax { get; set; }
|
|
public string DcnAreaMean { get; set; }
|
|
public string DcnAreaMin { get; set; }
|
|
public string DcnAreaStdDev { get; set; }
|
|
public string DcnBin1Max { get; set; }
|
|
public string DcnBin1Mean { get; set; }
|
|
public string DcnBin1Min { get; set; }
|
|
public string DcnBin1StdDev { get; set; }
|
|
public string DcnBin2Max { get; set; }
|
|
public string DcnBin2Mean { get; set; }
|
|
public string DcnBin2Min { get; set; }
|
|
public string DcnBin2StdDev { get; set; }
|
|
public string DcnBin3Max { get; set; }
|
|
public string DcnBin3Mean { get; set; }
|
|
public string DcnBin3Min { get; set; }
|
|
public string DcnBin3StdDev { get; set; }
|
|
public string DcnBin4Max { get; set; }
|
|
public string DcnBin4Mean { get; set; }
|
|
public string DcnBin4Min { get; set; }
|
|
public string DcnBin4StdDev { get; set; }
|
|
public string DcnBin5Max { get; set; }
|
|
public string DcnBin5Mean { get; set; }
|
|
public string DcnBin5Min { get; set; }
|
|
public string DcnBin5StdDev { get; set; }
|
|
public string DcnBin6Max { get; set; }
|
|
public string DcnBin6Mean { get; set; }
|
|
public string DcnBin6Min { get; set; }
|
|
public string DcnBin6StdDev { get; set; }
|
|
public string DcnBin7Max { get; set; }
|
|
public string DcnBin7Mean { get; set; }
|
|
public string DcnBin7Min { get; set; }
|
|
public string DcnBin7StdDev { get; set; }
|
|
public string DcnBin8Max { get; set; }
|
|
public string DcnBin8Mean { get; set; }
|
|
public string DcnBin8Min { get; set; }
|
|
public string DcnBin8StdDev { get; set; }
|
|
public string DcnHazeAvgMax { get; set; }
|
|
public string DcnHazeAvgMean { get; set; }
|
|
public string DcnHazeAvgMin { get; set; }
|
|
public string DcnHazeAvgStdDev { get; set; }
|
|
public string DcnHazeMedianMax { get; set; }
|
|
public string DcnHazeMedianMean { get; set; }
|
|
public string DcnHazeMedianMin { get; set; }
|
|
public string DcnHazeMedianStdDev { get; set; }
|
|
public string DcnHazeStdDevMax { get; set; }
|
|
public string DcnHazeStdDevMean { get; set; }
|
|
public string DcnHazeStdDevMin { get; set; }
|
|
public string DcnHazeStdDevStdDev { get; set; }
|
|
public string DcnLpdESMax { get; set; }
|
|
public string DcnLpdESMean { get; set; }
|
|
public string DcnLpdESMin { get; set; }
|
|
public string DcnLpdESStdDev { get; set; }
|
|
public string DcnLpdMax { get; set; }
|
|
public string DcnLpdMean { get; set; }
|
|
public string DcnLpdMin { get; set; }
|
|
public string DcnLpdNMax { get; set; }
|
|
public string DcnLpdNMean { get; set; }
|
|
public string DcnLpdNMin { get; set; }
|
|
public string DcnLpdNStdDev { get; set; }
|
|
public string DcnLpdStdDev { get; set; }
|
|
public string DcnMicroScrMax { get; set; }
|
|
public string DcnMicroScrMean { get; set; }
|
|
public string DcnMicroScrMin { get; set; }
|
|
public string DcnMicroScrStdDev { get; set; }
|
|
public string DcnScrMax { get; set; }
|
|
public string DcnScrMean { get; set; }
|
|
public string DcnScrMin { get; set; }
|
|
public string DcnScrStdDev { get; set; }
|
|
public string DcnSlipMax { get; set; }
|
|
public string DcnSlipMean { get; set; }
|
|
public string DcnSlipMin { get; set; }
|
|
public string DcnSlipStdDev { get; set; }
|
|
public string DnnAllMax { get; set; }
|
|
public string DnnAllMean { get; set; }
|
|
public string DnnAllMin { get; set; }
|
|
public string DnnAllStdDev { get; set; }
|
|
public string DnnAreaCountMax { get; set; }
|
|
public string DnnAreaCountMean { get; set; }
|
|
public string DnnAreaCountMin { get; set; }
|
|
public string DnnAreaCountStdDev { get; set; }
|
|
public string DnnAreaMax { get; set; }
|
|
public string DnnAreaMean { get; set; }
|
|
public string DnnAreaMin { get; set; }
|
|
public string DnnAreaStdDev { get; set; }
|
|
public string DnnBin1Max { get; set; }
|
|
public string DnnBin1Mean { get; set; }
|
|
public string DnnBin1Min { get; set; }
|
|
public string DnnBin1StdDev { get; set; }
|
|
public string DnnBin2Max { get; set; }
|
|
public string DnnBin2Mean { get; set; }
|
|
public string DnnBin2Min { get; set; }
|
|
public string DnnBin2StdDev { get; set; }
|
|
public string DnnBin3Max { get; set; }
|
|
public string DnnBin3Mean { get; set; }
|
|
public string DnnBin3Min { get; set; }
|
|
public string DnnBin3StdDev { get; set; }
|
|
public string DnnBin4Max { get; set; }
|
|
public string DnnBin4Mean { get; set; }
|
|
public string DnnBin4Min { get; set; }
|
|
public string DnnBin4StdDev { get; set; }
|
|
public string DnnBin5Max { get; set; }
|
|
public string DnnBin5Mean { get; set; }
|
|
public string DnnBin5Min { get; set; }
|
|
public string DnnBin5StdDev { get; set; }
|
|
public string DnnBin6Max { get; set; }
|
|
public string DnnBin6Mean { get; set; }
|
|
public string DnnBin6Min { get; set; }
|
|
public string DnnBin6StdDev { get; set; }
|
|
public string DnnBin7Max { get; set; }
|
|
public string DnnBin7Mean { get; set; }
|
|
public string DnnBin7Min { get; set; }
|
|
public string DnnBin7StdDev { get; set; }
|
|
public string DnnBin8Max { get; set; }
|
|
public string DnnBin8Mean { get; set; }
|
|
public string DnnBin8Min { get; set; }
|
|
public string DnnBin8StdDev { get; set; }
|
|
public string DnnHazeAvgMax { get; set; }
|
|
public string DnnHazeAvgMean { get; set; }
|
|
public string DnnHazeAvgMin { get; set; }
|
|
public string DnnHazeAvgStdDev { get; set; }
|
|
public string DnnHazeMedianMax { get; set; }
|
|
public string DnnHazeMedianMean { get; set; }
|
|
public string DnnHazeMedianMin { get; set; }
|
|
public string DnnHazeMedianStdDev { get; set; }
|
|
public string DnnHazeStdDevMax { get; set; }
|
|
public string DnnHazeStdDevMean { get; set; }
|
|
public string DnnHazeStdDevMin { get; set; }
|
|
public string DnnHazeStdDevStdDev { get; set; }
|
|
public string DnnLpdESMax { get; set; }
|
|
public string DnnLpdESMean { get; set; }
|
|
public string DnnLpdESMin { get; set; }
|
|
public string DnnLpdESStdDev { get; set; }
|
|
public string DnnLpdMax { get; set; }
|
|
public string DnnLpdMean { get; set; }
|
|
public string DnnLpdMin { get; set; }
|
|
public string DnnLpdNMax { get; set; }
|
|
public string DnnLpdNMean { get; set; }
|
|
public string DnnLpdNMin { get; set; }
|
|
public string DnnLpdNStdDev { get; set; }
|
|
public string DnnLpdStdDev { get; set; }
|
|
public string DnnMicroScrMax { get; set; }
|
|
public string DnnMicroScrMean { get; set; }
|
|
public string DnnMicroScrMin { get; set; }
|
|
public string DnnMicroScrStdDev { get; set; }
|
|
public string DnnScrMax { get; set; }
|
|
public string DnnScrMean { get; set; }
|
|
public string DnnScrMin { get; set; }
|
|
public string DnnScrStdDev { get; set; }
|
|
public string DnnSlipMax { get; set; }
|
|
public string DnnSlipMean { get; set; }
|
|
public string DnnSlipMin { get; set; }
|
|
public string DnnSlipStdDev { get; set; }
|
|
public string DwnAllMax { get; set; }
|
|
public string DwnAllMean { get; set; }
|
|
public string DwnAllMin { get; set; }
|
|
public string DwnAllStdDev { get; set; }
|
|
public string DwnAreaCountMax { get; set; }
|
|
public string DwnAreaCountMean { get; set; }
|
|
public string DwnAreaCountMin { get; set; }
|
|
public string DwnAreaCountStdDev { get; set; }
|
|
public string DwnAreaMax { get; set; }
|
|
public string DwnAreaMean { get; set; }
|
|
public string DwnAreaMin { get; set; }
|
|
public string DwnAreaStdDev { get; set; }
|
|
public string DwnBin1Max { get; set; }
|
|
public string DwnBin1Mean { get; set; }
|
|
public string DwnBin1Min { get; set; }
|
|
public string DwnBin1StdDev { get; set; }
|
|
public string DwnBin2Max { get; set; }
|
|
public string DwnBin2Mean { get; set; }
|
|
public string DwnBin2Min { get; set; }
|
|
public string DwnBin2StdDev { get; set; }
|
|
public string DwnBin3Max { get; set; }
|
|
public string DwnBin3Mean { get; set; }
|
|
public string DwnBin3Min { get; set; }
|
|
public string DwnBin3StdDev { get; set; }
|
|
public string DwnBin4Max { get; set; }
|
|
public string DwnBin4Mean { get; set; }
|
|
public string DwnBin4Min { get; set; }
|
|
public string DwnBin4StdDev { get; set; }
|
|
public string DwnBin5Max { get; set; }
|
|
public string DwnBin5Mean { get; set; }
|
|
public string DwnBin5Min { get; set; }
|
|
public string DwnBin5StdDev { get; set; }
|
|
public string DwnBin6Max { get; set; }
|
|
public string DwnBin6Mean { get; set; }
|
|
public string DwnBin6Min { get; set; }
|
|
public string DwnBin6StdDev { get; set; }
|
|
public string DwnBin7Max { get; set; }
|
|
public string DwnBin7Mean { get; set; }
|
|
public string DwnBin7Min { get; set; }
|
|
public string DwnBin7StdDev { get; set; }
|
|
public string DwnBin8Max { get; set; }
|
|
public string DwnBin8Mean { get; set; }
|
|
public string DwnBin8Min { get; set; }
|
|
public string DwnBin8StdDev { get; set; }
|
|
public string DwnHazeAvgMax { get; set; }
|
|
public string DwnHazeAvgMean { get; set; }
|
|
public string DwnHazeAvgMin { get; set; }
|
|
public string DwnHazeAvgStdDev { get; set; }
|
|
public string DwnHazeMedianMax { get; set; }
|
|
public string DwnHazeMedianMean { get; set; }
|
|
public string DwnHazeMedianMin { get; set; }
|
|
public string DwnHazeMedianStdDev { get; set; }
|
|
public string DwnHazeStdDevMax { get; set; }
|
|
public string DwnHazeStdDevMean { get; set; }
|
|
public string DwnHazeStdDevMin { get; set; }
|
|
public string DwnHazeStdDevStdDev { get; set; }
|
|
public string DwnLpdESMax { get; set; }
|
|
public string DwnLpdESMean { get; set; }
|
|
public string DwnLpdESMin { get; set; }
|
|
public string DwnLpdESStdDev { get; set; }
|
|
public string DwnLpdMax { get; set; }
|
|
public string DwnLpdMean { get; set; }
|
|
public string DwnLpdMin { get; set; }
|
|
public string DwnLpdNMax { get; set; }
|
|
public string DwnLpdNMean { get; set; }
|
|
public string DwnLpdNMin { get; set; }
|
|
public string DwnLpdNStdDev { get; set; }
|
|
public string DwnLpdStdDev { get; set; }
|
|
public string DwnMicroScrMax { get; set; }
|
|
public string DwnMicroScrMean { get; set; }
|
|
public string DwnMicroScrMin { get; set; }
|
|
public string DwnMicroScrStdDev { get; set; }
|
|
public string DwnScrMax { get; set; }
|
|
public string DwnScrMean { get; set; }
|
|
public string DwnScrMin { get; set; }
|
|
public string DwnScrStdDev { get; set; }
|
|
public string DwnSlipMax { get; set; }
|
|
public string DwnSlipMean { get; set; }
|
|
public string DwnSlipMin { get; set; }
|
|
public string DwnSlipStdDev { get; set; }
|
|
|
|
List<object> Shared.Properties.IProcessData.Details => _Details;
|
|
|
|
public ProcessData(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection)
|
|
{
|
|
fileInfoCollection.Clear();
|
|
_Details = new List<object>();
|
|
_I = 0;
|
|
_Data = string.Empty;
|
|
JobID = logistics.JobID;
|
|
MesEntity = logistics.MesEntity;
|
|
Date = DateTime.Now.ToString();
|
|
_Log = LogManager.GetLogger(typeof(ProcessData));
|
|
Parse(fileRead, logistics, fileInfoCollection);
|
|
}
|
|
|
|
string IProcessData.GetCurrentReactor(IFileRead fileRead, Logistics logistics, Dictionary<string, string> reactors) => throw new Exception(string.Concat("See ", nameof(Parse)));
|
|
|
|
Tuple<string, Test[], JsonElement[], List<FileInfo>> IProcessData.GetResults(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection)
|
|
{
|
|
Tuple<string, Test[], JsonElement[], List<FileInfo>> results;
|
|
List<Test> tests = new();
|
|
foreach (object item in _Details)
|
|
tests.Add(Test.SP1);
|
|
List<IDescription> descriptions = fileRead.GetDescriptions(fileRead, tests, this);
|
|
if (tests.Count != descriptions.Count)
|
|
throw new Exception();
|
|
for (int i = 0; i < tests.Count; i++)
|
|
{
|
|
if (descriptions[i] is not Description description)
|
|
throw new Exception();
|
|
if (description.Test != (int)tests[i])
|
|
throw new Exception();
|
|
}
|
|
List<Description> fileReadDescriptions = (from l in descriptions select (Description)l).ToList();
|
|
string json = JsonSerializer.Serialize(fileReadDescriptions, fileReadDescriptions.GetType());
|
|
JsonElement[] jsonElements = JsonSerializer.Deserialize<JsonElement[]>(json);
|
|
results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(logistics.Logistics1[0], tests.ToArray(), jsonElements, fileInfoCollection);
|
|
return results;
|
|
}
|
|
|
|
private void ScanPast(string text)
|
|
{
|
|
int num = _Data.IndexOf(text, _I);
|
|
if (num > -1)
|
|
_I = num + text.Length;
|
|
else
|
|
_I = _Data.Length;
|
|
}
|
|
|
|
private string GetBefore(string text)
|
|
{
|
|
int num = _Data.IndexOf(text, _I);
|
|
if (num > -1)
|
|
{
|
|
string str = _Data.Substring(_I, num - _I);
|
|
_I = num + text.Length;
|
|
return str.Trim();
|
|
}
|
|
string str1 = _Data.Substring(_I);
|
|
_I = _Data.Length;
|
|
return str1.Trim();
|
|
}
|
|
|
|
private string GetBefore(string text, bool trim)
|
|
{
|
|
if (trim)
|
|
return GetBefore(text);
|
|
int num = _Data.IndexOf(text, _I);
|
|
if (num > -1)
|
|
{
|
|
string str = _Data.Substring(_I, num - _I);
|
|
_I = num + text.Length;
|
|
return str;
|
|
}
|
|
string str1 = _Data.Substring(_I);
|
|
_I = _Data.Length;
|
|
return str1;
|
|
}
|
|
|
|
private static bool IsNullOrWhiteSpace(string text)
|
|
{
|
|
for (int index = 0; index < text.Length; ++index)
|
|
{
|
|
if (!char.IsWhiteSpace(text[index]))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private bool IsBlankLine()
|
|
{
|
|
int num = _Data.IndexOf("\n", _I);
|
|
return IsNullOrWhiteSpace(num > -1 ? _Data.Substring(_I, num - _I) : _Data.Substring(_I));
|
|
}
|
|
|
|
private string GetToEOL() => GetBefore("\n");
|
|
|
|
private string GetToEOL(bool trim)
|
|
{
|
|
if (trim)
|
|
return GetToEOL();
|
|
return GetBefore("\n", false);
|
|
}
|
|
|
|
private string GetToText(string text) => _Data.Substring(_I, _Data.IndexOf(text, _I) - _I).Trim();
|
|
|
|
private string GetToken()
|
|
{
|
|
while (_I < _Data.Length && IsNullOrWhiteSpace(_Data.Substring(_I, 1)))
|
|
++_I;
|
|
int j = _I;
|
|
while (j < _Data.Length && !IsNullOrWhiteSpace(_Data.Substring(j, 1)))
|
|
++j;
|
|
string str = _Data.Substring(_I, j - _I);
|
|
_I = j;
|
|
return str.Trim();
|
|
}
|
|
|
|
private string PeekNextLine()
|
|
{
|
|
int j = _I;
|
|
string toEol = GetToEOL();
|
|
_I = j;
|
|
return toEol;
|
|
}
|
|
|
|
private void GetWaferSummaryInfo(List<WaferSummaryInfo> waferSummaryInfos, string whichInfo)
|
|
{
|
|
ScanPast(whichInfo);
|
|
_ = GetToEOL();
|
|
_ = GetToEOL();
|
|
_ = GetToEOL();
|
|
_ = GetToEOL();
|
|
string[] segments;
|
|
WaferSummaryInfo waferSummaryInfo;
|
|
const string grade = "F Grade";
|
|
const string reject = "F Reject";
|
|
const string overLoad = "F OverLoad";
|
|
for (string line = PeekNextLine(); line[0] != '-'; line = PeekNextLine())
|
|
{
|
|
line = GetToEOL();
|
|
waferSummaryInfo = new WaferSummaryInfo();
|
|
if (line.StartsWith(grade))
|
|
line = line.Replace(grade, string.Concat("F -1", grade.Substring(4)));
|
|
else if (line.StartsWith(reject))
|
|
line = line.Replace(reject, string.Concat("F -1", reject.Substring(4)));
|
|
else if (line.StartsWith(overLoad))
|
|
line = line.Replace(overLoad, string.Concat("F -1", overLoad.Substring(4)));
|
|
segments = line.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
|
|
waferSummaryInfo.Side = segments[0];
|
|
waferSummaryInfo.WaferID = segments[1];
|
|
waferSummaryInfo.Grade = segments[2];
|
|
waferSummaryInfo.SrcDest = segments[3];
|
|
if (segments.Length > 4)
|
|
{
|
|
waferSummaryInfo.Lpd = segments[5];
|
|
waferSummaryInfo.LpdN = segments[6];
|
|
waferSummaryInfo.LpdES = segments[7];
|
|
waferSummaryInfo.MicroScr = segments[8];
|
|
waferSummaryInfo.Scr = segments[9];
|
|
waferSummaryInfo.Slip = segments[10];
|
|
waferSummaryInfo.AreaNum = segments[11];
|
|
waferSummaryInfo.Area = segments[12];
|
|
waferSummaryInfo.HazeAvg = segments[13];
|
|
waferSummaryInfo.HazeMedian = segments[14];
|
|
waferSummaryInfo.HazeStdDev = segments[15];
|
|
waferSummaryInfo.Bin1 = segments[16];
|
|
waferSummaryInfo.Bin2 = segments[17];
|
|
waferSummaryInfo.Bin3 = segments[18];
|
|
waferSummaryInfo.Bin4 = segments[19];
|
|
waferSummaryInfo.Bin5 = segments[20];
|
|
waferSummaryInfo.Bin6 = segments[21];
|
|
waferSummaryInfo.Bin7 = segments[22];
|
|
waferSummaryInfo.Bin8 = segments[23];
|
|
}
|
|
if (waferSummaryInfo.WaferID == "-1")
|
|
{
|
|
segments = waferSummaryInfo.SrcDest.Split('-')[0].Split('/');
|
|
waferSummaryInfo.WaferID = segments[segments.Length - 1];
|
|
}
|
|
waferSummaryInfos.Add(waferSummaryInfo);
|
|
}
|
|
}
|
|
|
|
private void ParseHeader(ILogistics logistics, List<WaferSummaryInfo> dcnTotals, List<WaferSummaryInfo> dwnTotals, List<WaferSummaryInfo> dnnTotals)
|
|
{
|
|
_I = 0;
|
|
_Data = string.Empty;
|
|
string summaryReportText = File.ReadAllText(logistics.ReportFullPath);
|
|
if (!string.IsNullOrEmpty(summaryReportText))
|
|
{
|
|
_Log.Debug("HeaderFile() - Beginning");
|
|
_I = 0;
|
|
_Data = summaryReportText;
|
|
ScanPast("Long Wafer Summary");
|
|
_ = GetToEOL();
|
|
ScanPast("Session:");
|
|
string toEOL = GetToEOL(true);
|
|
string str = toEOL;
|
|
Recipe = toEOL;
|
|
Session = str;
|
|
ScanPast("Lot ID:");
|
|
Lot = GetToEOL(true);
|
|
// Remove illegal characters \/:*?"<>| found in the Lot.
|
|
Lot = Regex.Replace(Lot, @"[\\,\/,\:,\*,\?,\"",\<,\>,\|]", "_").Split('\r')[0].Split('\n')[0];
|
|
string[] segments = Lot.Split(new char[] { '-' });
|
|
_Log.Debug("HeaderFile() - Debug A");
|
|
if (segments.Length > 1)
|
|
{
|
|
Reactor = segments[0];
|
|
RDS = segments[1];
|
|
if (segments.Length > 2)
|
|
{
|
|
PSN = segments[2];
|
|
if (segments.Length > 3)
|
|
Operator = segments[3];
|
|
}
|
|
}
|
|
_Log.Debug("HeaderFile() - Debug B");
|
|
_I = 0;
|
|
_Data = summaryReportText;
|
|
GetWaferSummaryInfo(dcnTotals, "DCN Totals");
|
|
ScanPast("Min");
|
|
segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
|
|
DcnAllMin = segments[0];
|
|
DcnLpdMin = segments[1];
|
|
DcnLpdNMin = segments[2];
|
|
DcnLpdESMin = segments[3];
|
|
DcnMicroScrMin = segments[4];
|
|
DcnScrMin = segments[5];
|
|
DcnSlipMin = segments[6];
|
|
DcnAreaCountMin = segments[7];
|
|
DcnAreaMin = segments[8];
|
|
DcnHazeAvgMin = segments[9];
|
|
DcnHazeMedianMin = segments[10];
|
|
DcnHazeStdDevMin = segments[11];
|
|
DcnBin1Min = segments[12];
|
|
DcnBin2Min = segments[13];
|
|
DcnBin3Min = segments[14];
|
|
DcnBin4Min = segments[15];
|
|
DcnBin5Min = segments[16];
|
|
DcnBin6Min = segments[17];
|
|
DcnBin7Min = segments[18];
|
|
DcnBin8Min = segments[19];
|
|
ScanPast("Max");
|
|
segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
|
|
DcnAllMax = segments[0];
|
|
DcnLpdMax = segments[1];
|
|
DcnLpdNMax = segments[2];
|
|
DcnLpdESMax = segments[3];
|
|
DcnMicroScrMax = segments[4];
|
|
DcnScrMax = segments[5];
|
|
DcnSlipMax = segments[6];
|
|
DcnAreaCountMax = segments[7];
|
|
DcnAreaMax = segments[8];
|
|
DcnHazeAvgMax = segments[9];
|
|
DcnHazeMedianMax = segments[10];
|
|
DcnHazeStdDevMax = segments[11];
|
|
DcnBin1Max = segments[12];
|
|
DcnBin2Max = segments[13];
|
|
DcnBin3Max = segments[14];
|
|
DcnBin4Max = segments[15];
|
|
DcnBin5Max = segments[16];
|
|
DcnBin6Max = segments[17];
|
|
DcnBin7Max = segments[18];
|
|
DcnBin8Max = segments[19];
|
|
ScanPast("Mean");
|
|
segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
|
|
DcnAllMean = segments[0];
|
|
DcnLpdMean = segments[1];
|
|
DcnLpdNMean = segments[2];
|
|
DcnLpdESMean = segments[3];
|
|
DcnMicroScrMean = segments[4];
|
|
DcnScrMean = segments[5];
|
|
DcnSlipMean = segments[6];
|
|
DcnAreaCountMean = segments[7];
|
|
DcnAreaMean = segments[8];
|
|
DcnHazeAvgMean = segments[9];
|
|
DcnHazeMedianMean = segments[10];
|
|
DcnHazeStdDevMean = segments[11];
|
|
DcnBin1Mean = segments[12];
|
|
DcnBin2Mean = segments[13];
|
|
DcnBin3Mean = segments[14];
|
|
DcnBin4Mean = segments[15];
|
|
DcnBin5Mean = segments[16];
|
|
DcnBin6Mean = segments[17];
|
|
DcnBin7Mean = segments[18];
|
|
DcnBin8Mean = segments[19];
|
|
ScanPast("Std. Dev.");
|
|
segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
|
|
DcnAllStdDev = segments[0];
|
|
DcnLpdStdDev = segments[1];
|
|
DcnLpdNStdDev = segments[2];
|
|
DcnLpdESStdDev = segments[3];
|
|
DcnMicroScrStdDev = segments[4];
|
|
DcnScrStdDev = segments[5];
|
|
DcnSlipStdDev = segments[6];
|
|
DcnAreaCountStdDev = segments[7];
|
|
DcnAreaStdDev = segments[8];
|
|
DcnHazeAvgStdDev = segments[9];
|
|
DcnHazeMedianStdDev = segments[10];
|
|
DcnHazeStdDevStdDev = segments[11];
|
|
DcnBin1StdDev = segments[12];
|
|
DcnBin2StdDev = segments[13];
|
|
DcnBin3StdDev = segments[14];
|
|
DcnBin4StdDev = segments[15];
|
|
DcnBin5StdDev = segments[16];
|
|
DcnBin6StdDev = segments[17];
|
|
DcnBin7StdDev = segments[18];
|
|
DcnBin8StdDev = segments[19];
|
|
_I = 0;
|
|
_Data = summaryReportText;
|
|
_Log.Debug("HeaderFile() - Debug C");
|
|
if (!_Data.Contains("DWN Totals"))
|
|
{
|
|
for (int i = 0; i < dcnTotals.Count; i++)
|
|
dwnTotals.Add(new WaferSummaryInfo());
|
|
}
|
|
else
|
|
{
|
|
GetWaferSummaryInfo(dwnTotals, "DWN Totals");
|
|
ScanPast("Min");
|
|
segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
|
|
DwnAllMin = segments[0];
|
|
DwnLpdMin = segments[1];
|
|
DwnLpdNMin = segments[2];
|
|
DwnLpdESMin = segments[3];
|
|
DwnMicroScrMin = segments[4];
|
|
DwnScrMin = segments[5];
|
|
DwnSlipMin = segments[6];
|
|
DwnAreaCountMin = segments[7];
|
|
DwnAreaMin = segments[8];
|
|
DwnHazeAvgMin = segments[9];
|
|
DwnHazeMedianMin = segments[10];
|
|
DwnHazeStdDevMin = segments[11];
|
|
DwnBin1Min = segments[12];
|
|
DwnBin2Min = segments[13];
|
|
DwnBin3Min = segments[14];
|
|
DwnBin4Min = segments[15];
|
|
DwnBin5Min = segments[16];
|
|
DwnBin6Min = segments[17];
|
|
DwnBin7Min = segments[18];
|
|
DwnBin8Min = segments[19];
|
|
ScanPast("Max");
|
|
segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
|
|
DwnAllMax = segments[0];
|
|
DwnLpdMax = segments[1];
|
|
DwnLpdNMax = segments[2];
|
|
DwnLpdESMax = segments[3];
|
|
DwnMicroScrMax = segments[4];
|
|
DwnScrMax = segments[5];
|
|
DwnSlipMax = segments[6];
|
|
DwnAreaCountMax = segments[7];
|
|
DwnAreaMax = segments[8];
|
|
DwnHazeAvgMax = segments[9];
|
|
DwnHazeMedianMax = segments[10];
|
|
DwnHazeStdDevMax = segments[11];
|
|
DwnBin1Max = segments[12];
|
|
DwnBin2Max = segments[13];
|
|
DwnBin3Max = segments[14];
|
|
DwnBin4Max = segments[15];
|
|
DwnBin5Max = segments[16];
|
|
DwnBin6Max = segments[17];
|
|
DwnBin7Max = segments[18];
|
|
DwnBin8Max = segments[19];
|
|
ScanPast("Mean");
|
|
segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
|
|
DwnAllMean = segments[0];
|
|
DwnLpdMean = segments[1];
|
|
DwnLpdNMean = segments[2];
|
|
DwnLpdESMean = segments[3];
|
|
DwnMicroScrMean = segments[4];
|
|
DwnScrMean = segments[5];
|
|
DwnSlipMean = segments[6];
|
|
DwnAreaCountMean = segments[7];
|
|
DwnAreaMean = segments[8];
|
|
DwnHazeAvgMean = segments[9];
|
|
DwnHazeMedianMean = segments[10];
|
|
DwnHazeStdDevMean = segments[11];
|
|
DwnBin1Mean = segments[12];
|
|
DwnBin2Mean = segments[13];
|
|
DwnBin3Mean = segments[14];
|
|
DwnBin4Mean = segments[15];
|
|
DwnBin5Mean = segments[16];
|
|
DwnBin6Mean = segments[17];
|
|
DwnBin7Mean = segments[18];
|
|
DwnBin8Mean = segments[19];
|
|
ScanPast("Std. Dev.");
|
|
segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
|
|
DwnAllStdDev = segments[0];
|
|
DwnLpdStdDev = segments[1];
|
|
DwnLpdNStdDev = segments[2];
|
|
DwnLpdESStdDev = segments[3];
|
|
DwnMicroScrStdDev = segments[4];
|
|
DwnScrStdDev = segments[5];
|
|
DwnSlipStdDev = segments[6];
|
|
DwnAreaCountStdDev = segments[7];
|
|
DwnAreaStdDev = segments[8];
|
|
DwnHazeAvgStdDev = segments[9];
|
|
DwnHazeMedianStdDev = segments[10];
|
|
DwnHazeStdDevStdDev = segments[11];
|
|
DwnBin1StdDev = segments[12];
|
|
DwnBin2StdDev = segments[13];
|
|
DwnBin3StdDev = segments[14];
|
|
DwnBin4StdDev = segments[15];
|
|
DwnBin5StdDev = segments[16];
|
|
DwnBin6StdDev = segments[17];
|
|
DwnBin7StdDev = segments[18];
|
|
DwnBin8StdDev = segments[19];
|
|
}
|
|
_I = 0;
|
|
_Data = summaryReportText;
|
|
_Log.Debug("HeaderFile() - Debug D");
|
|
if (!_Data.Contains("DNN Totals"))
|
|
{
|
|
for (int i = 0; i < dcnTotals.Count; i++)
|
|
dnnTotals.Add(new WaferSummaryInfo());
|
|
}
|
|
else
|
|
{
|
|
GetWaferSummaryInfo(dnnTotals, "DNN Totals");
|
|
ScanPast("Min");
|
|
segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
|
|
DnnAllMin = segments[0];
|
|
DnnLpdMin = segments[1];
|
|
DnnLpdNMin = segments[2];
|
|
DnnLpdESMin = segments[3];
|
|
DnnMicroScrMin = segments[4];
|
|
DnnScrMin = segments[5];
|
|
DnnSlipMin = segments[6];
|
|
DnnAreaCountMin = segments[7];
|
|
DnnAreaMin = segments[8];
|
|
DnnHazeAvgMin = segments[9];
|
|
DnnHazeMedianMin = segments[10];
|
|
DnnHazeStdDevMin = segments[11];
|
|
DnnBin1Min = segments[12];
|
|
DnnBin2Min = segments[13];
|
|
DnnBin3Min = segments[14];
|
|
DnnBin4Min = segments[15];
|
|
DnnBin5Min = segments[16];
|
|
DnnBin6Min = segments[17];
|
|
DnnBin7Min = segments[18];
|
|
DnnBin8Min = segments[19];
|
|
ScanPast("Max");
|
|
segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
|
|
DnnAllMax = segments[0];
|
|
DnnLpdMax = segments[1];
|
|
DnnLpdNMax = segments[2];
|
|
DnnLpdESMax = segments[3];
|
|
DnnMicroScrMax = segments[4];
|
|
DnnScrMax = segments[5];
|
|
DnnSlipMax = segments[6];
|
|
DnnAreaCountMax = segments[7];
|
|
DnnAreaMax = segments[8];
|
|
DnnHazeAvgMax = segments[9];
|
|
DnnHazeMedianMax = segments[10];
|
|
DnnHazeStdDevMax = segments[11];
|
|
DnnBin1Max = segments[12];
|
|
DnnBin2Max = segments[13];
|
|
DnnBin3Max = segments[14];
|
|
DnnBin4Max = segments[15];
|
|
DnnBin5Max = segments[16];
|
|
DnnBin6Max = segments[17];
|
|
DnnBin7Max = segments[18];
|
|
DnnBin8Max = segments[19];
|
|
ScanPast("Mean");
|
|
segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
|
|
DnnAllMean = segments[0];
|
|
DnnLpdMean = segments[1];
|
|
DnnLpdNMean = segments[2];
|
|
DnnLpdESMean = segments[3];
|
|
DnnMicroScrMean = segments[4];
|
|
DnnScrMean = segments[5];
|
|
DnnSlipMean = segments[6];
|
|
DnnAreaCountMean = segments[7];
|
|
DnnAreaMean = segments[8];
|
|
DnnHazeAvgMean = segments[9];
|
|
DnnHazeMedianMean = segments[10];
|
|
DnnHazeStdDevMean = segments[11];
|
|
DnnBin1Mean = segments[12];
|
|
DnnBin2Mean = segments[13];
|
|
DnnBin3Mean = segments[14];
|
|
DnnBin4Mean = segments[15];
|
|
DnnBin5Mean = segments[16];
|
|
DnnBin6Mean = segments[17];
|
|
DnnBin7Mean = segments[18];
|
|
DnnBin8Mean = segments[19];
|
|
ScanPast("Std. Dev.");
|
|
segments = GetToEOL().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
|
|
DnnAllStdDev = segments[0];
|
|
DnnLpdStdDev = segments[1];
|
|
DnnLpdNStdDev = segments[2];
|
|
DnnLpdESStdDev = segments[3];
|
|
DnnMicroScrStdDev = segments[4];
|
|
DnnScrStdDev = segments[5];
|
|
DnnSlipStdDev = segments[6];
|
|
DnnAreaCountStdDev = segments[7];
|
|
DnnAreaStdDev = segments[8];
|
|
DnnHazeAvgStdDev = segments[9];
|
|
DnnHazeMedianStdDev = segments[10];
|
|
DnnHazeStdDevStdDev = segments[11];
|
|
DnnBin1StdDev = segments[12];
|
|
DnnBin2StdDev = segments[13];
|
|
DnnBin3StdDev = segments[14];
|
|
DnnBin4StdDev = segments[15];
|
|
DnnBin5StdDev = segments[16];
|
|
DnnBin6StdDev = segments[17];
|
|
DnnBin7StdDev = segments[18];
|
|
DnnBin8StdDev = segments[19];
|
|
}
|
|
}
|
|
//UniqueID = string.Format("{0}_{1}_Summary_{2}", logistics.JobID, Lot, Date);
|
|
UniqueID = string.Format("{0}_{1}_{2}", logistics.JobID, Lot, Path.GetFileNameWithoutExtension(logistics.ReportFullPath));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parse the wafer summary data
|
|
/// </summary>
|
|
/// <param name="headerFile">wafer data</param>
|
|
/// <param name="i">wafer index</param>
|
|
/// <returns></returns>
|
|
private Detail ParseWaferSummary(int i, List<WaferSummaryInfo> dcnTotals, List<WaferSummaryInfo> dwnTotals, List<WaferSummaryInfo> dnnTotals)
|
|
{
|
|
Detail result = new()
|
|
{
|
|
// NOTE: get the UniqueID during DataCalculation in order to retrieve the SPCToolID from the cell component Tag field.
|
|
// id
|
|
//runData.UniqueID = string.Format("{0}_{1}", sp1Header.UniqueId, i + 1);
|
|
//runData.HeaderUniqueID = sp1Header.UniqueId;
|
|
|
|
// General Wafer Info
|
|
Side = dcnTotals[i].Side,
|
|
WaferID = dcnTotals[i].WaferID,
|
|
Grade = dcnTotals[i].Grade,
|
|
SrcDest = dcnTotals[i].SrcDest,
|
|
|
|
// Dcn Info
|
|
DcnAll = dcnTotals[i].All ?? string.Empty,
|
|
DcnLpd = dcnTotals[i].Lpd ?? string.Empty,
|
|
DcnLpdN = dcnTotals[i].LpdN ?? string.Empty,
|
|
DcnLpdES = dcnTotals[i].LpdES ?? string.Empty,
|
|
DcnMicroScr = dcnTotals[i].MicroScr ?? string.Empty,
|
|
DcnScr = dcnTotals[i].Scr ?? string.Empty,
|
|
DcnSlip = dcnTotals[i].Slip ?? string.Empty,
|
|
DcnAreaCount = dcnTotals[i].AreaNum ?? string.Empty,
|
|
DcnArea = dcnTotals[i].Area ?? string.Empty,
|
|
DcnHazeAvg = dcnTotals[i].HazeAvg ?? string.Empty,
|
|
DcnHazeMedian = dcnTotals[i].HazeMedian ?? string.Empty,
|
|
DcnHazeStdDev = dcnTotals[i].HazeStdDev ?? string.Empty,
|
|
DcnBin1 = dcnTotals[i].Bin1 ?? string.Empty,
|
|
DcnBin2 = dcnTotals[i].Bin2 ?? string.Empty,
|
|
DcnBin3 = dcnTotals[i].Bin3 ?? string.Empty,
|
|
DcnBin4 = dcnTotals[i].Bin4 ?? string.Empty,
|
|
DcnBin5 = dcnTotals[i].Bin5 ?? string.Empty,
|
|
DcnBin6 = dcnTotals[i].Bin6 ?? string.Empty,
|
|
DcnBin7 = dcnTotals[i].Bin7 ?? string.Empty,
|
|
DcnBin8 = dcnTotals[i].Bin8 ?? string.Empty,
|
|
|
|
// Dwn Info
|
|
DwnAll = dwnTotals[i].All ?? string.Empty,
|
|
DwnLpd = dwnTotals[i].Lpd ?? string.Empty,
|
|
DwnLpdN = dwnTotals[i].LpdN ?? string.Empty,
|
|
DwnLpdES = dwnTotals[i].LpdES ?? string.Empty,
|
|
DwnMicroScr = dwnTotals[i].MicroScr ?? string.Empty,
|
|
DwnScr = dwnTotals[i].Scr ?? string.Empty,
|
|
DwnSlip = dwnTotals[i].Slip ?? string.Empty,
|
|
DwnAreaCount = dwnTotals[i].AreaNum ?? string.Empty,
|
|
DwnArea = dwnTotals[i].Area ?? string.Empty,
|
|
DwnHazeAvg = dwnTotals[i].HazeAvg ?? string.Empty,
|
|
DwnHazeMedian = dwnTotals[i].HazeMedian ?? string.Empty,
|
|
DwnHazeStdDev = dwnTotals[i].HazeStdDev ?? string.Empty,
|
|
DwnBin1 = dwnTotals[i].Bin1 ?? string.Empty,
|
|
DwnBin2 = dwnTotals[i].Bin2 ?? string.Empty,
|
|
DwnBin3 = dwnTotals[i].Bin3 ?? string.Empty,
|
|
DwnBin4 = dwnTotals[i].Bin4 ?? string.Empty,
|
|
DwnBin5 = dwnTotals[i].Bin5 ?? string.Empty,
|
|
DwnBin6 = dwnTotals[i].Bin6 ?? string.Empty,
|
|
DwnBin7 = dwnTotals[i].Bin7 ?? string.Empty,
|
|
DwnBin8 = dwnTotals[i].Bin8 ?? string.Empty,
|
|
|
|
// Dnn Info
|
|
DnnAll = dnnTotals[i].All ?? string.Empty,
|
|
DnnLpd = dnnTotals[i].Lpd ?? string.Empty,
|
|
DnnLpdN = dnnTotals[i].LpdN ?? string.Empty,
|
|
DnnLpdES = dnnTotals[i].LpdES ?? string.Empty,
|
|
DnnMicroScr = dnnTotals[i].MicroScr ?? string.Empty,
|
|
DnnScr = dnnTotals[i].Scr ?? string.Empty,
|
|
DnnSlip = dnnTotals[i].Slip ?? string.Empty,
|
|
DnnAreaCount = dnnTotals[i].AreaNum ?? string.Empty,
|
|
DnnArea = dnnTotals[i].Area ?? string.Empty,
|
|
DnnHazeAvg = dnnTotals[i].HazeAvg ?? string.Empty,
|
|
DnnHazeMedian = dnnTotals[i].HazeMedian ?? string.Empty,
|
|
DnnHazeStdDev = dnnTotals[i].HazeStdDev ?? string.Empty,
|
|
DnnBin1 = dnnTotals[i].Bin1 ?? string.Empty,
|
|
DnnBin2 = dnnTotals[i].Bin2 ?? string.Empty,
|
|
DnnBin3 = dnnTotals[i].Bin3 ?? string.Empty,
|
|
DnnBin4 = dnnTotals[i].Bin4 ?? string.Empty,
|
|
DnnBin5 = dnnTotals[i].Bin5 ?? string.Empty,
|
|
DnnBin6 = dnnTotals[i].Bin6 ?? string.Empty,
|
|
DnnBin7 = dnnTotals[i].Bin7 ?? string.Empty,
|
|
DnnBin8 = dnnTotals[i].Bin8 ?? string.Empty,
|
|
//result.HeaderUniqueID = string.Concat(MesEntity, "_", Lot, "_Summary_", Date);
|
|
HeaderUniqueID = UniqueID
|
|
};
|
|
result.UniqueID = string.Concat(result.HeaderUniqueID, "_", result.WaferID.PadLeft(2, '0'));
|
|
return result;
|
|
}
|
|
|
|
private void Parse(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection)
|
|
{
|
|
if (fileRead is null)
|
|
{ }
|
|
Detail dataFile;
|
|
foreach (string file in Directory.GetFiles(Path.GetDirectoryName(logistics.ReportFullPath), "WaferMap*.prn", SearchOption.TopDirectoryOnly))
|
|
fileInfoCollection.Add(new FileInfo(file));
|
|
List<WaferSummaryInfo> dcnTotals = new();
|
|
List<WaferSummaryInfo> dwnTotals = new();
|
|
List<WaferSummaryInfo> dnnTotals = new();
|
|
ParseHeader(logistics, dcnTotals, dwnTotals, dnnTotals);
|
|
_Log.Debug($"Number of wafers: {dcnTotals.Count}");
|
|
for (int i = 0; i < dcnTotals.Count; i++)
|
|
{
|
|
_Log.Debug($"****ParseData - Parsing wafer summary: {i}");
|
|
dataFile = ParseWaferSummary(i, dcnTotals, dwnTotals, dnnTotals);
|
|
_Details.Add(dataFile);
|
|
}
|
|
fileInfoCollection.Add(logistics.FileInfo);
|
|
}
|
|
|
|
#nullable enable
|
|
|
|
internal static List<Description> GetDescriptions(JsonElement[] jsonElements)
|
|
{
|
|
List<Description> results = new();
|
|
Description? description;
|
|
JsonSerializerOptions jsonSerializerOptions = new() { NumberHandling = JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.WriteAsString };
|
|
foreach (JsonElement jsonElement in jsonElements)
|
|
{
|
|
if (jsonElement.ValueKind != JsonValueKind.Object)
|
|
throw new Exception();
|
|
description = JsonSerializer.Deserialize<Description>(jsonElement.ToString(), jsonSerializerOptions);
|
|
if (description is null)
|
|
continue;
|
|
results.Add(description);
|
|
}
|
|
return results;
|
|
}
|
|
|
|
} |