Mike Phares
3c30da0bb1
Bug in yml dotnet tool PackageReference arrangement RDS Blank Change int dotnet test nuget ^ [spcepiworld].[dbo].[evnt_inf] Assembly Version WS Result bug fix and Nuget bump, PSN, Reactor and Extra RDS rule OpenInsightApi and testRunTitle editorconfig bugs Fix Type serializerValue RDS oversight PropertyNameCaseInsensitive SP1 was different Save check for file already present NoWaitDirectory MoveArchive allow empty directory and continueOnError for clean files CreatePointerFile and more on NoWaitDirectory
1063 lines
43 KiB
C#
1063 lines
43 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 DateTime Date { 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; }
|
|
public string Employee { get; set; }
|
|
public string Lot { 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; }
|
|
|
|
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;
|
|
_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 static (string, string) GetReactorAndRDS(string defaultReactor, string defaultRDS, string text, string formattedText, string[] segments, bool hasRDS)
|
|
{
|
|
string rds;
|
|
string reactor;
|
|
if (string.IsNullOrEmpty(text) || segments.Length == 0 || string.IsNullOrEmpty(formattedText) || (segments.Length > 1 && !hasRDS))
|
|
reactor = defaultReactor;
|
|
else
|
|
reactor = segments[0];
|
|
if (segments.Length <= 1 || !int.TryParse(segments[1], out int rdsValue) || rdsValue < 99)
|
|
rds = defaultRDS;
|
|
else
|
|
rds = segments[1];
|
|
if (reactor.Length > 3)
|
|
{
|
|
rds = reactor;
|
|
reactor = defaultReactor;
|
|
}
|
|
return new(reactor, rds);
|
|
}
|
|
|
|
private static (string, string) GetLayerAndPSN(string defaultLayer, string defaultPSN, string[] segments, bool hasRDS)
|
|
{
|
|
string psn;
|
|
string layer;
|
|
if (segments.Length <= 2 || (segments.Length > 1 && !hasRDS))
|
|
{
|
|
psn = defaultPSN;
|
|
layer = defaultLayer;
|
|
}
|
|
else
|
|
{
|
|
string[] segmentsB = segments[2].Split('.');
|
|
psn = segmentsB[0];
|
|
if (segmentsB.Length <= 1)
|
|
layer = defaultLayer;
|
|
else
|
|
{
|
|
layer = segmentsB[1];
|
|
if (layer.Length > 1 && layer[0] == '0')
|
|
layer = layer.Substring(1);
|
|
}
|
|
}
|
|
return (layer, psn);
|
|
}
|
|
|
|
private static string GetZone(string[] segments)
|
|
{
|
|
string result;
|
|
if (segments.Length <= 3)
|
|
result = string.Empty;
|
|
else
|
|
{
|
|
result = segments[3];
|
|
if (result.Length > 1 && result[0] == '0')
|
|
result = result.Substring(1);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static Descriptor GetDescriptor(string text)
|
|
{
|
|
Descriptor result;
|
|
string lot;
|
|
string psn;
|
|
string rds;
|
|
string zone;
|
|
string layer;
|
|
string reactor;
|
|
string employee;
|
|
string defaultPSN = string.Empty;
|
|
string defaultRDS = string.Empty;
|
|
string defaultZone = string.Empty;
|
|
string defaultLayer = string.Empty;
|
|
string defaultReactor = string.Empty;
|
|
string defaultEmployee = string.Empty;
|
|
if (string.IsNullOrEmpty(text) || (text.Length is 2 or 3 && Regex.IsMatch(text, "^[a-zA-z]{2,3}")))
|
|
{
|
|
lot = text;
|
|
employee = text;
|
|
psn = defaultPSN;
|
|
rds = defaultRDS;
|
|
zone = defaultZone;
|
|
layer = defaultLayer;
|
|
reactor = defaultReactor;
|
|
}
|
|
else if (Regex.IsMatch(text, @"^[0-9]{2}[.][0-9]{1}[.]?[0-9]{0,1}"))
|
|
{
|
|
string[] segments = text.Split('.');
|
|
lot = text;
|
|
psn = defaultPSN;
|
|
rds = defaultRDS;
|
|
layer = segments[1];
|
|
reactor = segments[0];
|
|
employee = defaultEmployee;
|
|
if (segments.Length <= 2)
|
|
zone = defaultZone;
|
|
else
|
|
zone = segments[2];
|
|
}
|
|
else
|
|
{
|
|
// Remove illegal characters \/:*?"<>| found in the Lot.
|
|
lot = Regex.Replace(text, @"[\\,\/,\:,\*,\?,\"",\<,\>,\|]", "_").Split('\r')[0].Split('\n')[0];
|
|
if (lot.Length > 2 && lot[0] == '1' && (lot[1] == 'T' || lot[1] == 't'))
|
|
lot = lot.Substring(2);
|
|
string[] segments = lot.Split('-');
|
|
bool hasRDS = Regex.IsMatch(lot, "[-]?[0-9]{5,}[-]?");
|
|
(reactor, rds) = GetReactorAndRDS(defaultReactor, defaultRDS, text, lot, segments, hasRDS);
|
|
(layer, psn) = GetLayerAndPSN(defaultLayer, defaultPSN, segments, hasRDS);
|
|
zone = GetZone(segments);
|
|
employee = defaultEmployee;
|
|
}
|
|
result = new(employee, layer, lot, psn, rds, reactor, zone);
|
|
return result;
|
|
}
|
|
|
|
private void Set(ILogistics logistics, string summaryReportText)
|
|
{
|
|
_I = 0;
|
|
string lot;
|
|
string rds;
|
|
string psn;
|
|
string recipe;
|
|
string reactor;
|
|
string session;
|
|
string employee;
|
|
Descriptor descriptor;
|
|
_Data = summaryReportText;
|
|
_Log.Debug("HeaderFile() - Beginning");
|
|
if (string.IsNullOrEmpty(summaryReportText))
|
|
{
|
|
recipe = string.Empty;
|
|
session = string.Empty;
|
|
descriptor = GetDescriptor(summaryReportText);
|
|
lot = descriptor.Lot;
|
|
psn = descriptor.PSN;
|
|
rds = descriptor.RDS;
|
|
reactor = descriptor.Reactor;
|
|
employee = descriptor.Employee;
|
|
}
|
|
else
|
|
{
|
|
ScanPast("Long Wafer Summary");
|
|
_ = GetToEOL();
|
|
ScanPast("Session:");
|
|
recipe = GetToEOL(true);
|
|
session = recipe;
|
|
ScanPast("Lot ID:");
|
|
lot = GetToEOL(true);
|
|
descriptor = GetDescriptor(lot);
|
|
lot = descriptor.Lot;
|
|
psn = descriptor.PSN;
|
|
rds = descriptor.RDS;
|
|
reactor = descriptor.Reactor;
|
|
employee = descriptor.Employee;
|
|
}
|
|
Lot = lot;
|
|
PSN = psn;
|
|
RDS = rds;
|
|
Recipe = recipe;
|
|
Reactor = reactor;
|
|
Session = session;
|
|
Employee = employee;
|
|
UniqueID = string.Format("{0}_{1}_{2}", logistics.JobID, lot, Path.GetFileNameWithoutExtension(logistics.ReportFullPath));
|
|
}
|
|
|
|
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);
|
|
Set(logistics, summaryReportText);
|
|
if (!string.IsNullOrEmpty(summaryReportText))
|
|
{
|
|
_Log.Debug("HeaderFile() - Debug B");
|
|
_I = 0;
|
|
string[] segments;
|
|
_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];
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <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;
|
|
}
|
|
|
|
} |