Mike Phares
3966b75da7
run.json descriptions.json MissingMethodException Infineon.Mesa.PDF.Text.Stripper 4.8.0.2 MSTEST0037
719 lines
27 KiB
C#
719 lines
27 KiB
C#
using Adaptation.Shared;
|
|
using Adaptation.Shared.Methods;
|
|
using log4net;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Data;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text.Json;
|
|
using System.Text.Json.Serialization;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace Adaptation.FileHandlers.pcl;
|
|
|
|
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 AreaCountAvg { get; set; }
|
|
public string AreaCountMax { get; set; }
|
|
public string AreaCountMin { get; set; }
|
|
public string AreaCountStdDev { get; set; }
|
|
public string AreaTotalAvg { get; set; }
|
|
public string AreaTotalMax { get; set; }
|
|
public string AreaTotalMin { get; set; }
|
|
public string AreaTotalStdDev { get; set; }
|
|
public DateTime Date { get; set; }
|
|
public string Employee { get; set; }
|
|
public string HazeAverageAvg { get; set; }
|
|
public string HazeAverageMax { get; set; }
|
|
public string HazeAverageMin { get; set; }
|
|
public string HazeAverageStdDev { get; set; }
|
|
public string HazeRegionAvg { get; set; }
|
|
public string HazeRegionMax { get; set; }
|
|
public string HazeRegionMin { get; set; }
|
|
public string HazeRegionStdDev { get; set; }
|
|
public string LPDCM2Avg { get; set; }
|
|
public string LPDCM2Max { get; set; }
|
|
public string LPDCM2Min { get; set; }
|
|
public string LPDCM2StdDev { get; set; }
|
|
public string LPDCountAvg { get; set; }
|
|
public string LPDCountMax { get; set; }
|
|
public string LPDCountMin { get; set; }
|
|
public string LPDCountStdDev { get; set; }
|
|
public string Lot { get; set; }
|
|
public string PSN { get; set; }
|
|
public string ParseErrorText { get; set; }
|
|
public string RDS { get; set; }
|
|
public string Reactor { get; set; }
|
|
public string Recipe { get; set; }
|
|
public string ScratchCountAvg { get; set; }
|
|
public string ScratchCountMax { get; set; }
|
|
public string ScratchCountMin { get; set; }
|
|
public string ScratchCountStdDev { get; set; }
|
|
public string ScratchTotalAvg { get; set; }
|
|
public string ScratchTotalMax { get; set; }
|
|
public string ScratchTotalMin { get; set; }
|
|
public string ScratchTotalStdDev { get; set; }
|
|
public string SumOfDefectsAvg { get; set; }
|
|
public string SumOfDefectsMax { get; set; }
|
|
public string SumOfDefectsMin { get; set; }
|
|
public string SumOfDefectsStdDev { get; set; }
|
|
public string UniqueId { get; set; }
|
|
|
|
List<object> Shared.Properties.IProcessData.Details => _Details;
|
|
|
|
internal ProcessData(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection, ReadOnlyDictionary<string, string> pages, Run run)
|
|
{
|
|
_Details = new List<object>();
|
|
_I = 0;
|
|
_Data = string.Empty;
|
|
JobID = logistics.JobID;
|
|
Date = GetDateTime(logistics);
|
|
MesEntity = logistics.MesEntity;
|
|
_Log = LogManager.GetLogger(typeof(ProcessData));
|
|
Parse(fileRead, logistics, fileInfoCollection, pages, run);
|
|
}
|
|
|
|
private static DateTime GetDateTime(Logistics logistics) =>
|
|
logistics.DateTimeFromSequence;
|
|
|
|
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.Tencor);
|
|
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();
|
|
}
|
|
FileInfo fileInfo = new($"{logistics.ReportFullPath}.descriptions.json");
|
|
List<Description> fileReadDescriptions = (from l in descriptions select (Description)l).ToList();
|
|
string json = JsonSerializer.Serialize(fileReadDescriptions, fileReadDescriptions.GetType());
|
|
File.WriteAllText(fileInfo.FullName, json);
|
|
File.SetLastWriteTime(fileInfo.FullName, logistics.DateTimeFromSequence);
|
|
fileInfoCollection.Add(fileInfo);
|
|
JsonElement[] jsonElements = JsonSerializer.Deserialize<JsonElement[]>(json) ?? throw new Exception();
|
|
results = new Tuple<string, Test[], JsonElement[], List<FileInfo>>(logistics.Logistics1[0], tests.ToArray(), jsonElements, fileInfoCollection);
|
|
return results;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Test and fix a data line from the Lot Summary page if there are two values that are merged.
|
|
/// </summary>
|
|
/// <param name="toEol">data line from Lot Summary</param>
|
|
private void FixToEolArray(ref string[] toEol)
|
|
{
|
|
const int MAX_COLUMNS = 9;
|
|
int[] mColumnWidths = new int[MAX_COLUMNS] { 8, 6, 6, 6, 6, 7, 7, 5, 7 };
|
|
// is it short at least one data point
|
|
if (toEol.Length < MAX_COLUMNS)
|
|
{
|
|
_Log.Debug($"****FixToEolArray - Starting array:");
|
|
_Log.Debug(toEol);
|
|
_Log.Debug($"****FixToEolArray - Column widths:");
|
|
_Log.Debug(mColumnWidths);
|
|
string leftVal, rightVal;
|
|
|
|
// size up and assign a working list
|
|
List<string> toEolList = new(toEol);
|
|
if (string.IsNullOrEmpty(toEolList[toEolList.Count - 1]))
|
|
toEolList.RemoveAt(toEolList.Count - 1); // removes a null element at end
|
|
_Log.Debug($"****FixToEolArray - New toEolList:");
|
|
_Log.Debug(toEolList);
|
|
for (int i = toEolList.Count; i < MAX_COLUMNS; i++)
|
|
toEolList.Insert(0, ""); // insert to top of list
|
|
_Log.Debug(toEolList);
|
|
|
|
// start at the end
|
|
for (int i = MAX_COLUMNS - 1; i >= 0; i--)
|
|
{
|
|
// test for a bad value - does it have too many characters
|
|
_Log.Debug($"****FixToEolArray - toEolList[i].Length: {toEolList[i].Length}, mColumnWidths[i]: {mColumnWidths[i]}");
|
|
if (toEolList[i].Length > mColumnWidths[i])
|
|
{
|
|
// split it up into its two parts
|
|
leftVal = toEolList[i].Substring(0, toEolList[i].Length - mColumnWidths[i]);
|
|
rightVal = toEolList[i].Substring(leftVal.Length);
|
|
_Log.Debug($"****FixToEolArray - Split leftVal: {leftVal}");
|
|
_Log.Debug($"****FixToEolArray - Split rightVal: {rightVal}");
|
|
|
|
// insert new value
|
|
toEolList[i] = rightVal;
|
|
toEolList.Insert(i, leftVal);
|
|
if (string.IsNullOrEmpty(toEolList[0]))
|
|
toEolList.RemoveAt(0); // removes a null element at end
|
|
_Log.Debug($"****FixToEolArray - Fixed toEolList:");
|
|
_Log.Debug(toEolList);
|
|
}
|
|
}
|
|
toEol = toEolList.ToArray();
|
|
_Log.Debug($"****FixToEolArray - Ending array:");
|
|
_Log.Debug(toEol);
|
|
}
|
|
}
|
|
|
|
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 result = GetToEOL();
|
|
_I = j;
|
|
return result;
|
|
}
|
|
|
|
private static (string, string) GetReactorAndRDS(string defaultReactor, string defaultRDS, string text, string formattedText, string[] segments)
|
|
{
|
|
string rds;
|
|
string reactor;
|
|
if (string.IsNullOrEmpty(text) || segments.Length == 0 || string.IsNullOrEmpty(formattedText))
|
|
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)
|
|
{
|
|
string psn;
|
|
string layer;
|
|
if (segments.Length <= 2)
|
|
{
|
|
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 (Regex.IsMatch(text, @"^[a-zA-z][0-9]{2,4}$"))
|
|
{
|
|
lot = text.ToUpper();
|
|
psn = defaultPSN;
|
|
rds = defaultRDS;
|
|
zone = defaultZone;
|
|
layer = defaultLayer;
|
|
reactor = defaultReactor;
|
|
employee = defaultEmployee;
|
|
}
|
|
else 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, "[-]?([QP][0-9]{4,}|[0-9]{5,})[-]?");
|
|
(reactor, rds) = GetReactorAndRDS(defaultReactor, defaultRDS, text, lot, segments);
|
|
(layer, psn) = GetLayerAndPSN(defaultLayer, defaultPSN, segments);
|
|
zone = GetZone(segments);
|
|
employee = defaultEmployee;
|
|
}
|
|
result = new(employee, layer, lot, psn, rds, reactor, zone);
|
|
return result;
|
|
}
|
|
|
|
private void Set(ILogistics logistics, Run run)
|
|
{
|
|
string lot;
|
|
string rds;
|
|
string psn;
|
|
string recipe;
|
|
string reactor;
|
|
string employee;
|
|
ScanPast("Recipe ID:");
|
|
_ = GetBefore("LotID:");
|
|
lot = run.Header.Id;
|
|
recipe = run.Header.Recipe;
|
|
Descriptor 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;
|
|
Employee = employee;
|
|
UniqueId = string.Format("{0}_{1}_{2}", logistics.JobID, lot, Path.GetFileNameWithoutExtension(logistics.ReportFullPath));
|
|
}
|
|
|
|
private void ParseLotSummary(ILogistics logistics, ReadOnlyDictionary<string, string> pages, Run run, string headerFileName, Dictionary<string, List<Detail>> slots)
|
|
{
|
|
_I = 0;
|
|
ParseErrorText = string.Empty;
|
|
if (!pages.TryGetValue(headerFileName, out string value))
|
|
throw new Exception();
|
|
_I = 0;
|
|
_Data = value;
|
|
ScanPast("Date:");
|
|
_ = GetToEOL();
|
|
Set(logistics, run);
|
|
// determine number of wafers and their slot numbers
|
|
_Log.Debug(_Data.Substring(_I));
|
|
string slot;
|
|
string toEOL;
|
|
int slotCount = _Data.Substring(_I).Split('*').Length - 1;
|
|
_Log.Debug($"****HeaderFile - Slot Count: {slotCount}.");
|
|
for (int i = 0; i < slotCount; i++)
|
|
{
|
|
ScanPast("*");
|
|
toEOL = GetToEOL(false);
|
|
slot = string.Concat("*", toEOL.Substring(0, 2));
|
|
if (!slots.ContainsKey(slot))
|
|
slots.Add(slot, new List<Detail>());
|
|
}
|
|
_Log.Debug($"****HeaderFile - Slots:");
|
|
_Log.Debug(slots);
|
|
|
|
ScanPast("Min:");
|
|
|
|
string[] toEol1 = GetToEOL(false).Trim().Split(' ');
|
|
_Log.Debug($"****HeaderFile - toEol1 Count: {toEol1.Length}.");
|
|
FixToEolArray(ref toEol1);
|
|
LPDCountMin = toEol1[0].Trim();
|
|
LPDCM2Min = toEol1[1].Trim();
|
|
AreaCountMin = toEol1[2].Trim();
|
|
AreaTotalMin = toEol1[3].Trim();
|
|
ScratchCountMin = toEol1[4].Trim();
|
|
ScratchTotalMin = toEol1[5].Trim();
|
|
SumOfDefectsMin = toEol1[6].Trim();
|
|
HazeRegionMin = toEol1[7].Trim();
|
|
HazeAverageMin = toEol1[8].Trim();
|
|
ScanPast("Max:");
|
|
|
|
string[] toEol2 = GetToEOL(false).Trim().Split(' ');
|
|
_Log.Debug($"****HeaderFile - toEol2 Count: {toEol2.Length}.");
|
|
FixToEolArray(ref toEol2);
|
|
LPDCountMax = toEol2[0].Trim();
|
|
LPDCM2Max = toEol2[1].Trim();
|
|
AreaCountMax = toEol2[2].Trim();
|
|
AreaTotalMax = toEol2[3].Trim();
|
|
ScratchCountMax = toEol2[4].Trim();
|
|
ScratchTotalMax = toEol2[5].Trim();
|
|
SumOfDefectsMax = toEol2[6].Trim();
|
|
HazeRegionMax = toEol2[7].Trim();
|
|
HazeAverageMax = toEol2[8].Trim();
|
|
ScanPast("Average:");
|
|
|
|
string[] toEol3 = GetToEOL(false).Trim().Split(' ');
|
|
_Log.Debug($"****HeaderFile - toEol3 Count: {toEol3.Length}.");
|
|
FixToEolArray(ref toEol3);
|
|
LPDCountAvg = toEol3[0].Trim();
|
|
LPDCM2Avg = toEol3[1].Trim();
|
|
AreaCountAvg = toEol3[2].Trim();
|
|
AreaTotalAvg = toEol3[3].Trim();
|
|
ScratchCountAvg = toEol3[4].Trim();
|
|
ScratchTotalAvg = toEol3[5].Trim();
|
|
SumOfDefectsAvg = toEol3[6].Trim();
|
|
HazeRegionAvg = toEol3[7].Trim();
|
|
HazeAverageAvg = toEol3[8].Trim();
|
|
ScanPast("Std Dev:");
|
|
|
|
string[] toEol4 = GetToEOL(false).Trim().Split(' ');
|
|
_Log.Debug($"****HeaderFile - toEol4 Count: {toEol4.Length}.");
|
|
FixToEolArray(ref toEol4);
|
|
LPDCountStdDev = toEol4[0].Trim();
|
|
LPDCM2StdDev = toEol4[1].Trim();
|
|
AreaCountStdDev = toEol4[2].Trim();
|
|
AreaTotalStdDev = toEol4[3].Trim();
|
|
ScratchCountStdDev = toEol4[4].Trim();
|
|
ScratchTotalStdDev = toEol4[5].Trim();
|
|
SumOfDefectsStdDev = toEol4[6].Trim();
|
|
HazeRegionStdDev = toEol4[7].Trim();
|
|
HazeAverageStdDev = toEol4[8].Trim();
|
|
}
|
|
|
|
private Detail ParseWaferSummary(string waferFileName, ReadOnlyDictionary<string, string> pages)
|
|
{
|
|
Detail result = new() { Data = "*Data*", i = -1, };
|
|
_I = 0;
|
|
List<string> stringList = new();
|
|
result.HeaderUniqueId = UniqueId;
|
|
result.Id = 0;
|
|
result.Title = null;
|
|
if (!pages.TryGetValue(waferFileName, out string value))
|
|
throw new Exception();
|
|
_I = 0;
|
|
_Data = value;
|
|
ScanPast("Date:");
|
|
result.Date = GetToEOL();
|
|
ScanPast("ID#");
|
|
result.Slot = GetToEOL();
|
|
if (result.Slot.Length > 5)
|
|
result.Slot = string.Concat(result.Slot.Substring(0, 5), "... - ***");
|
|
//result.Slot = result.Slot.Replace("*", "");
|
|
ScanPast("Comments:");
|
|
result.Comments = GetToEOL();
|
|
ScanPast("Sort:");
|
|
result.Sort = GetToEOL();
|
|
ScanPast("LPD Count:");
|
|
result.LPDCount = GetToEOL();
|
|
ScanPast("LPD / cm2:");
|
|
result.LPDCM2 = GetToEOL();
|
|
while (GetBefore(":").Contains("Bin"))
|
|
stringList.Add(GetToEOL());
|
|
if (stringList.Count >= 1)
|
|
result.Bin1 = stringList[0];
|
|
if (stringList.Count >= 2)
|
|
result.Bin2 = stringList[1];
|
|
if (stringList.Count >= 3)
|
|
result.Bin3 = stringList[2];
|
|
if (stringList.Count >= 4)
|
|
result.Bin4 = stringList[3];
|
|
if (stringList.Count >= 5)
|
|
result.Bin5 = stringList[4];
|
|
if (stringList.Count >= 6)
|
|
result.Bin6 = stringList[5];
|
|
if (stringList.Count >= 7)
|
|
result.Bin7 = stringList[6];
|
|
if (stringList.Count >= 8)
|
|
result.Bin8 = stringList[7];
|
|
result.Mean = GetToEOL();
|
|
ScanPast("Std Dev:");
|
|
result.StdDev = GetToEOL();
|
|
ScanPast("Area Count:");
|
|
result.AreaCount = GetToEOL();
|
|
ScanPast("Area Total:");
|
|
result.AreaTotal = GetToEOL();
|
|
ScanPast("Scratch Count:");
|
|
result.ScratchCount = GetToEOL();
|
|
ScanPast("Scratch Total:");
|
|
result.ScratchTotal = GetToEOL();
|
|
ScanPast("Sum of All Defects:");
|
|
result.SumOfDefects = GetToEOL();
|
|
ScanPast("Haze Region:");
|
|
result.HazeRegion = GetToEOL();
|
|
ScanPast("Haze Average:");
|
|
result.HazeAverage = GetToEOL();
|
|
ScanPast("Haze Peak:");
|
|
result.HazePeak = GetToEOL();
|
|
ScanPast("Laser:");
|
|
result.Laser = GetBefore("Gain:");
|
|
result.Gain = GetBefore("Diameter:");
|
|
result.Diameter = GetToEOL();
|
|
ScanPast("Thresh:");
|
|
result.Thresh = GetBefore("Exclusion:");
|
|
result.Exclusion = GetToEOL();
|
|
ScanPast("Haze Rng:");
|
|
result.HazeRng = GetBefore("Thruput:");
|
|
result.Thruput = GetToEOL();
|
|
ScanPast("Recipe ID:");
|
|
result.Recipe = GetToEOL();
|
|
result.UniqueId = string.Format("{0}_{1}", UniqueId, result.Slot.Replace("*", string.Empty).TrimStart('0'));
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert the raw data file to parsable file format - in this case from PCL to PDF
|
|
/// </summary>
|
|
/// <param name="sourceFile">source file to be converted to PDF</param>
|
|
/// <returns></returns>
|
|
private static string ConvertSourceFileToPdf(string ghostPCLFileName, Logistics logistics)
|
|
{
|
|
string result = Path.ChangeExtension(logistics.ReportFullPath, ".pdf");
|
|
if (!File.Exists(result))
|
|
{
|
|
//string arguments = string.Concat("-i \"", sourceFile, "\" -o \"", result, "\"");
|
|
string arguments = string.Concat("-dSAFER -dBATCH -dNOPAUSE -sOutputFile=\"", result, "\" -sDEVICE=pdfwrite \"", logistics.ReportFullPath, "\"");
|
|
//Process process = Process.Start(configData.LincPDFCFileName, arguments);
|
|
Process process = Process.Start(ghostPCLFileName, arguments);
|
|
_ = process.WaitForExit(30000);
|
|
if (!File.Exists(result))
|
|
throw new Exception("PDF file wasn't created");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
#nullable enable
|
|
|
|
private void Parse(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection, ReadOnlyDictionary<string, string> pages, Run run)
|
|
{
|
|
if (fileRead is null)
|
|
throw new ArgumentNullException(nameof(fileRead));
|
|
List<string> sourceFiles = new();
|
|
List<string> missingSlots = new();
|
|
Dictionary<string, List<Detail>> slots = new();
|
|
List<Tuple<string, string>> pageMapping = new();
|
|
_Log.Debug($"****ParseData - Parsing lot summary");
|
|
string headerFileName = pages.ElementAt(pages.Count - 1).Key;
|
|
ParseLotSummary(logistics, pages, run, headerFileName, slots);
|
|
string sourcePath = Path.GetDirectoryName(logistics.ReportFullPath) ?? throw new Exception();
|
|
string sourceFileNameWithoutExtension = Path.GetFileNameWithoutExtension(logistics.ReportFullPath);
|
|
foreach (FileInfo fileInfo in fileInfoCollection)
|
|
sourceFiles.Add(fileInfo.FullName);
|
|
fileInfoCollection.Clear();
|
|
foreach (KeyValuePair<string, string> keyValuePair in pages)
|
|
{
|
|
if (keyValuePair.Key == headerFileName)
|
|
continue;
|
|
if (string.IsNullOrEmpty(keyValuePair.Value.Trim()))
|
|
{
|
|
pageMapping.Add(new Tuple<string, string>(keyValuePair.Key, string.Empty));
|
|
continue;
|
|
}
|
|
if (!pages.ContainsKey(keyValuePair.Key))
|
|
throw new Exception();
|
|
Detail dataFile = ParseWaferSummary(keyValuePair.Key, pages);
|
|
if (string.IsNullOrEmpty(dataFile.Recipe) || dataFile.Recipe != Recipe)
|
|
{
|
|
missingSlots.Add(keyValuePair.Key);
|
|
pageMapping.Add(new Tuple<string, string>(keyValuePair.Key, string.Empty));
|
|
continue;
|
|
}
|
|
if (!slots.ContainsKey(dataFile.Slot))
|
|
{
|
|
missingSlots.Add(keyValuePair.Key);
|
|
pageMapping.Add(new Tuple<string, string>(keyValuePair.Key, string.Empty));
|
|
continue;
|
|
}
|
|
pageMapping.Add(new Tuple<string, string>(keyValuePair.Key, string.Concat(sourcePath, @"\", sourceFileNameWithoutExtension, "_", dataFile.Slot.Replace('*', 's'), "_data.pdf")));
|
|
slots[dataFile.Slot].Add(dataFile);
|
|
}
|
|
string checkFileName = string.Concat(sourcePath, @"\", sourceFileNameWithoutExtension, "_data.pdf");
|
|
if (fileRead.IsEAFHosted && !File.Exists(checkFileName))
|
|
{
|
|
File.Move(headerFileName, checkFileName);
|
|
_ = sourceFiles.Remove(headerFileName);
|
|
sourceFiles.Add(checkFileName);
|
|
}
|
|
checkFileName = string.Empty;
|
|
for (int i = pageMapping.Count - 1; i > -1; i--)
|
|
{
|
|
if (!string.IsNullOrEmpty(pageMapping[i].Item2))
|
|
{
|
|
checkFileName = pageMapping[i].Item2;
|
|
if (fileRead.IsEAFHosted && !File.Exists(checkFileName))
|
|
{
|
|
File.Move(pageMapping[i].Item1, checkFileName);
|
|
_ = sourceFiles.Remove(pageMapping[i].Item1);
|
|
sourceFiles.Add(checkFileName);
|
|
}
|
|
}
|
|
else if (!string.IsNullOrEmpty(checkFileName))
|
|
{
|
|
checkFileName = checkFileName.Replace("_data.pdf", "_image.pdf");
|
|
if (fileRead.IsEAFHosted && !File.Exists(checkFileName))
|
|
{
|
|
File.Move(pageMapping[i].Item1, checkFileName);
|
|
_ = sourceFiles.Remove(pageMapping[i].Item1);
|
|
sourceFiles.Add(checkFileName);
|
|
}
|
|
checkFileName = string.Empty;
|
|
}
|
|
}
|
|
foreach (KeyValuePair<string, List<Detail>> keyValuePair in slots)
|
|
{
|
|
if (keyValuePair.Value.Count == 0 || keyValuePair.Value[0] is null)
|
|
missingSlots.Add(string.Concat("Slot ", keyValuePair.Key, ") is missing."));
|
|
else
|
|
{
|
|
foreach (Detail data in keyValuePair.Value)
|
|
_Details.Add(data);
|
|
}
|
|
}
|
|
if (missingSlots.Count != 0)
|
|
{
|
|
string missingSlotsFile = string.Concat(sourcePath, @"\", sourceFileNameWithoutExtension, "_MissingSlots.txt");
|
|
File.WriteAllLines(missingSlotsFile, missingSlots);
|
|
sourceFiles.Add(missingSlotsFile);
|
|
}
|
|
//for (int i = 0; i < dataFiles.Count; i++)
|
|
// dataFiles[i].Date = DateTime.Parse(dataFiles[i].Date).ToString();
|
|
foreach (string sourceFile in sourceFiles)
|
|
fileInfoCollection.Add(new FileInfo(sourceFile));
|
|
fileInfoCollection.Add(logistics.FileInfo);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
} |