393 lines
17 KiB
C#
393 lines
17 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.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text.Json;
|
|
using System.Text.Json.Serialization;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace Adaptation.FileHandlers.QS408M;
|
|
|
|
public partial class ProcessData : IProcessData
|
|
{
|
|
|
|
private readonly List<object> _Details;
|
|
|
|
public string JobID { get; set; }
|
|
public string MesEntity { get; set; }
|
|
public string Batch { get; set; }
|
|
public string Cassette { get; set; }
|
|
public DateTime Date { get; set; }
|
|
public string Employee { get; set; }
|
|
public string Layer { get; set; }
|
|
public string MeanThickness { get; set; }
|
|
public string PSN { get; set; }
|
|
public string PassFail { get; set; }
|
|
public string RDS { get; set; }
|
|
public string RVThickness { get; set; }
|
|
public string Reactor { get; set; }
|
|
public string Recipe { get; set; }
|
|
public string StdDev { get; set; }
|
|
public string Title { get; set; }
|
|
public string UniqueId { get; set; }
|
|
public string Wafer { get; set; }
|
|
public string Zone { get; set; }
|
|
//
|
|
public string Slot { get; set; }
|
|
public string ThicknessFourteen3mmEdgeMean { get; set; }
|
|
public string ThicknessFourteen3mmEdgePercent { get; set; }
|
|
public string ThicknessFourteen5mmEdgeMean { get; set; }
|
|
public string ThicknessFourteen5mmEdgePercent { get; set; }
|
|
public string ThicknessFourteenCenterMean { get; set; }
|
|
public string ThicknessFourteenCriticalPointsAverage { get; set; }
|
|
public string ThicknessFourteenCriticalPointsStdDev { get; set; }
|
|
public string ThicknessFourteenMeanFrom { get; set; }
|
|
|
|
List<object> Shared.Properties.IProcessData.Details => _Details;
|
|
|
|
private readonly ILog _Log;
|
|
|
|
public ProcessData()
|
|
{
|
|
}
|
|
|
|
public ProcessData(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection, string originalDataBioRad, LastProcessData lastProcessData, long tickOffset)
|
|
{
|
|
JobID = logistics.JobID;
|
|
fileInfoCollection.Clear();
|
|
_Details = new List<object>();
|
|
MesEntity = logistics.MesEntity;
|
|
_Log = LogManager.GetLogger(typeof(ProcessData));
|
|
TXT txt = Parse(fileRead, logistics, fileInfoCollection, originalDataBioRad, lastProcessData);
|
|
if (txt is not null)
|
|
SetValues(logistics, tickOffset, txt);
|
|
}
|
|
|
|
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.BioRadQS408M);
|
|
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;
|
|
}
|
|
|
|
internal static DateTime GetDateTime(Logistics logistics, long tickOffset, string dateTimeText)
|
|
{
|
|
DateTime result;
|
|
string inputDateFormat = "ddd mmm dd HH:mm:ss yyyy";
|
|
if (dateTimeText.Length != inputDateFormat.Length)
|
|
result = logistics.DateTimeFromSequence;
|
|
else
|
|
{
|
|
if (!DateTime.TryParseExact(dateTimeText, inputDateFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime dateTimeParsed))
|
|
result = logistics.DateTimeFromSequence;
|
|
else
|
|
{
|
|
if (dateTimeParsed < logistics.DateTimeFromSequence.AddDays(1) && dateTimeParsed > logistics.DateTimeFromSequence.AddDays(-1))
|
|
result = new(dateTimeParsed.Ticks + tickOffset);
|
|
else
|
|
result = logistics.DateTimeFromSequence;
|
|
}
|
|
}
|
|
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 psn;
|
|
string rds;
|
|
string zone;
|
|
string layer;
|
|
string wafer;
|
|
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}$"))
|
|
{
|
|
wafer = 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}")))
|
|
{
|
|
wafer = 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('.');
|
|
wafer = 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 Batch
|
|
wafer = Regex.Replace(text, @"[\\,\/,\:,\*,\?,\"",\<,\>,\|]", "_").Split('\r')[0].Split('\n')[0];
|
|
if (wafer.Length > 2 && wafer[0] == '1' && (wafer[1] == 'T' || wafer[1] == 't'))
|
|
wafer = wafer.Substring(2);
|
|
string[] segments = wafer.Split('-');
|
|
// bool hasRDS = Regex.IsMatch(wafer, "[-]?([QP][0-9]{4,}|[0-9]{5,})[-]?");
|
|
(reactor, rds) = GetReactorAndRDS(defaultReactor, defaultRDS, text, wafer, segments);
|
|
(layer, psn) = GetLayerAndPSN(defaultLayer, defaultPSN, segments);
|
|
zone = GetZone(segments);
|
|
if (segments.Length <= 4)
|
|
employee = defaultEmployee;
|
|
else
|
|
employee = segments[4];
|
|
}
|
|
result = new(employee, layer, psn, rds, reactor, wafer, zone);
|
|
return result;
|
|
}
|
|
|
|
#pragma warning disable IDE0060
|
|
private static TXT Parse(IFileRead fileRead, Logistics logistics, List<FileInfo> fileInfoCollection, string originalDataBioRad, LastProcessData lastProcessData)
|
|
#pragma warning restore IDE0060
|
|
{
|
|
TXT result;
|
|
List<string> moveFiles = new();
|
|
string directoryName = Path.GetDirectoryName(logistics.ReportFullPath);
|
|
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(logistics.ReportFullPath);
|
|
moveFiles.AddRange(Directory.GetFiles(directoryName, string.Concat(originalDataBioRad, "*", logistics.Sequence, "*"), SearchOption.TopDirectoryOnly));
|
|
moveFiles.AddRange(Directory.GetFiles(directoryName, string.Concat(originalDataBioRad, "*", fileNameWithoutExtension.Split('_').Last(), "*"), SearchOption.TopDirectoryOnly));
|
|
foreach (string moveFile in moveFiles.Distinct())
|
|
fileInfoCollection.Add(new FileInfo(moveFile));
|
|
string receivedData = File.ReadAllText(logistics.ReportFullPath);
|
|
// occasionally there are multiple blocks of details, get the last one as earlier ones may be aborted runs.
|
|
int index = receivedData.LastIndexOf("Bio-Rad");
|
|
if (index > -1)
|
|
receivedData = receivedData.Substring(index);
|
|
if (string.IsNullOrEmpty(receivedData))
|
|
result = null;
|
|
else
|
|
{
|
|
result = new TXT(lastProcessData, receivedData);
|
|
string fileName = Path.Combine(directoryName, $"{Path.GetFileNameWithoutExtension(logistics.ReportFullPath)}.json");
|
|
string json = JsonSerializer.Serialize(result, new JsonSerializerOptions { WriteIndented = true });
|
|
File.WriteAllText(fileName, json);
|
|
fileInfoCollection.Add(new(fileName));
|
|
}
|
|
fileInfoCollection.Add(logistics.FileInfo);
|
|
return result;
|
|
}
|
|
|
|
private void SetValues(Logistics logistics, long tickOffset, TXT txt)
|
|
{
|
|
int slot = 0;
|
|
Detail detail;
|
|
int counter = 1;
|
|
List<Detail> details = new();
|
|
DateTime dateTime = GetDateTime(logistics, tickOffset, txt.Header.DateTime);
|
|
bool isWaferSlot = !string.IsNullOrEmpty(txt.Header.Wafer) && txt.Header.Wafer.Length is 1 or 2 && int.TryParse(txt.Header.Wafer, out slot) && slot < 27;
|
|
string batch = !isWaferSlot ? logistics.JobID : Regex.Replace(txt.Header.Batch, @"[\\,\/,\:,\*,\?,\"",\<,\>,\|]", "_").Split('\r')[0].Split('\n')[0];
|
|
Descriptor descriptor = isWaferSlot ? GetDescriptor(txt.Header.Batch) : GetDescriptor(txt.Header.Wafer);
|
|
string wafer = isWaferSlot ? slot.ToString("00") : descriptor.Wafer;
|
|
string uniqueId = string.Concat(txt.Header.Title, '_', wafer, '_', logistics.DateTimeFromSequence.ToString("yyyyMMddHHmmssffff"), '_', logistics.TotalSecondsSinceLastWriteTimeFromSequence);
|
|
Batch = batch;
|
|
Wafer = wafer;
|
|
Date = dateTime;
|
|
UniqueId = uniqueId;
|
|
PSN = descriptor.PSN;
|
|
RDS = descriptor.RDS;
|
|
Zone = descriptor.Zone;
|
|
JobID = logistics.JobID;
|
|
Layer = descriptor.Layer;
|
|
StdDev = txt.Body.StdDev;
|
|
Title = txt.Header.Title;
|
|
Recipe = txt.Header.Recipe;
|
|
PassFail = txt.Body.PassFail;
|
|
Reactor = descriptor.Reactor;
|
|
Cassette = txt.Header.Cassette;
|
|
RVThickness = txt.Footer.RadialVariationThickness;
|
|
Slot = string.IsNullOrEmpty(txt.Footer.Slot) ? slot.ToString("00") : txt.Footer.Slot;
|
|
Employee = string.IsNullOrEmpty(txt.Header.Operator) ? Employee : txt.Header.Operator;
|
|
MeanThickness = string.IsNullOrEmpty(txt.Body.WaferMeanThickness) && txt.Body.Sites.Count == 1 ? txt.Body.Sites.First().Thickness : txt.Body.WaferMeanThickness;
|
|
foreach (Site site in txt.Body.Sites)
|
|
{
|
|
detail = new()
|
|
{
|
|
Position = site.Position,
|
|
HeaderUniqueId = uniqueId,
|
|
Thickness = site.Thickness,
|
|
UniqueId = string.Concat(uniqueId, "_Point-", counter)
|
|
};
|
|
details.Add(detail);
|
|
counter++;
|
|
}
|
|
PopulateCalculated(details);
|
|
_Details.AddRange(details);
|
|
}
|
|
|
|
#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;
|
|
}
|
|
|
|
private static double StandardDeviation(IEnumerable<double> values)
|
|
{
|
|
double avg = values.Average();
|
|
return Math.Sqrt(values.Average(v => Math.Pow(v - avg, 2)));
|
|
}
|
|
|
|
private void PopulateCalculated(List<Detail> details)
|
|
{
|
|
List<double> thicknessPoints = new();
|
|
foreach (Detail bioRadDetail in details)
|
|
{
|
|
if (!double.TryParse(bioRadDetail.Thickness, out double thickness))
|
|
thicknessPoints.Add(0);
|
|
else
|
|
thicknessPoints.Add(thickness);
|
|
}
|
|
if (thicknessPoints.Count != 14)
|
|
{
|
|
ThicknessFourteenMeanFrom = string.Empty;
|
|
ThicknessFourteenCenterMean = string.Empty;
|
|
ThicknessFourteen3mmEdgeMean = string.Empty;
|
|
ThicknessFourteen5mmEdgeMean = string.Empty;
|
|
ThicknessFourteen3mmEdgePercent = string.Empty;
|
|
ThicknessFourteen5mmEdgePercent = string.Empty;
|
|
ThicknessFourteenCriticalPointsStdDev = string.Empty;
|
|
ThicknessFourteenCriticalPointsAverage = string.Empty;
|
|
}
|
|
else
|
|
{
|
|
ReadOnlyCollection<double> thicknessTenPoints = new(thicknessPoints.Take(10).ToArray());
|
|
double thicknessFourteenCriticalPointsAverage = thicknessTenPoints.Average(); // 15
|
|
double thicknessFourteenCriticalPointsStdDev = StandardDeviation(thicknessTenPoints); // 16
|
|
double thicknessFourteenCenterMean = thicknessPoints[4]; // 17
|
|
double thicknessFourteenMeanFrom = new double[] { thicknessPoints[3], thicknessPoints[4], thicknessPoints[5], thicknessPoints[6] }.Average(); // 18
|
|
double thicknessFourteen5mmEdgeMean = new double[] { thicknessPoints[0], thicknessPoints[1], thicknessPoints[8], thicknessPoints[9] }.Average(); // 19
|
|
double thicknessFourteen3mmEdgeMean = new double[] { thicknessPoints[10], thicknessPoints[13] }.Average(); // 20
|
|
double thicknessFourteen5mmEdgePercent = (thicknessFourteen5mmEdgeMean - thicknessFourteenMeanFrom) / thicknessFourteenMeanFrom * 100; // 21
|
|
double thicknessFourteen3mmEdgePercent = (thicknessFourteen3mmEdgeMean - thicknessFourteenMeanFrom) / thicknessFourteenMeanFrom * 100; // 22
|
|
ThicknessFourteenCriticalPointsAverage = thicknessFourteenCriticalPointsAverage.ToString("0.0000000"); // 15
|
|
ThicknessFourteenCriticalPointsStdDev = thicknessFourteenCriticalPointsStdDev.ToString("0.0000000"); // 16
|
|
ThicknessFourteenCenterMean = thicknessFourteenCenterMean.ToString("0.0000000"); // 17
|
|
ThicknessFourteenMeanFrom = thicknessFourteenMeanFrom.ToString("0.0000000"); // 18
|
|
ThicknessFourteen5mmEdgeMean = thicknessFourteen5mmEdgeMean.ToString("0.0000000"); // 19
|
|
ThicknessFourteen3mmEdgeMean = thicknessFourteen3mmEdgeMean.ToString("0.0000000"); // 20
|
|
ThicknessFourteen5mmEdgePercent = thicknessFourteen5mmEdgePercent.ToString("0.0000000"); // 21
|
|
ThicknessFourteen3mmEdgePercent = thicknessFourteen3mmEdgePercent.ToString("0.0000000"); // 22
|
|
}
|
|
}
|
|
|
|
} |