public IFeatureCursor Search(IQueryFilter Filter, bool Recycling)
{
log.enterFunc("Search");
if (log.IsDebugEnabled)
{
log.Debug(Helper.objectToString(Filter) + "," + Recycling.ToString());
}
IFeatureCursor retVal = null;
try
{
string where;
string fields;
GeomHelper.aoQryToPostGisQry(Filter, postGisLayer, out fields, out where);
AutoDataReader dr = postGisLayer.doQuery(fields, where);
#if !STUB_BUILD
retVal = new PostGisFeatureCursor(this, dr);
#endif
}
finally
{
log.leaveFunc();
}
return(retVal);
}
static public ISpatialReference setEsriSpatiaReferenceFromSrText(int srid, Connection conn)
{
ISpatialReference sr = new UnknownCoordinateSystemClass();
string srText = "";
int i = 0;
try
{
//Bill: query srtext associated with srid
AutoDataReader dr = conn.doQuery("select * from spatial_ref_sys where srid = " + srid.ToString());
if (dr.Read())
{
srText = dr["srtext"] + "";
ISpatialReferenceFactory2 srf = new SpatialReferenceEnvironmentClass();
if (srText == "")
{
sr = new UnknownCoordinateSystemClass();
}
else
{
//use srText to construct SR.
srf.CreateESRISpatialReference(srText, out sr, out i);
}
}
return(sr);
}
catch
{
//PostGis srid is not implemented as an Esri Factory Code
sr = new UnknownCoordinateSystemClass();
return(sr);
}
}
static void Main(string[] args)
{
string inputDir = @"C:\Users\nx008314\OneDrive - Nexperia\Work\WaferFab\Auto";
string outputDir = @"C:\Users\nx008314\OneDrive - Nexperia\Work\WaferFab\SerializedFiles";
AutoDataReader reader = new AutoDataReader(inputDir, outputDir);
//SerializeWorkCenterLotActivities(reader, "LotActivity2019_2020.csv", "WorkCenterLotActivities_SmallTestSet", true);
//SerializeWaferFabSettings(reader, false);
SerializeLotTraces(reader, "LotActivity2019_2020_2021.csv", "LotTraces_2019_2020_2021");
//WriteLotActivitiesWithEPTsToCSV(reader, "LotTraces_2019_2020_2021.dat", "AllLotActivitiesWithEPTs_201920202021.csv");
SerializeLotStarts(reader, "2019_2020_2021");
////SerializeWaferFabSettings(reader, true);
//foreach (string wc in reader.WaferFabSettings.WorkCenters)
//{
// SerializeWaferFabSettings(reader, true, wc);
//}
//SerializeRealSnaphotsAll(reader, 1);
SerializeRealSnapshotsPerMonth(reader, 1);
}
/// <summary>
/// Serializes WorkCenterLotActivities. Uses waferfabsettings + raw lot activities (from Excel add-on Nexperia Tools > F/W Queries > LotsProdEqpt).
/// </summary>
/// <param name="lotActivitiesFilename"></param>
public static void SerializeWorkCenterLotActivities(AutoDataReader reader, string filenameLotActivities, string filenameSerializedOutput, bool onlyProductionLots)
{
reader.ReadWaferFabSettings(@"FittedEPTParameters.csv", false, true, DispatcherBase.Type.EPTOVERTAKING);
reader.ReadWorkCenterLotActivities(filenameLotActivities, onlyProductionLots);
reader.SerializeWorkCenterLotActivities($"{filenameSerializedOutput}");
}
/// <summary>
/// Serialized WaferFabSettings without the Distributions (Random class cannot be serialized).
/// </summary>
/// <param name="reader"></param>
/// <param name="area">Area to serialize, if not specified complete fab will be build.</param>
/// <param name="withLotStarts">With or without real lot starts</param>
public static void SerializeWaferFabSettings(AutoDataReader reader, bool withLotStarts, string area = "COMPLETE")
{
reader.ReadWaferFabSettings(@"FittedEPTParameters.csv", withLotStarts, false, DispatcherBase.Type.EPTOVERTAKING, area);
string fileName = withLotStarts ? $"WaferFabSettings_{area}_WithLotStarts" : $"WaferFabSettings_{area}_NoLotStarts";
reader.SerializeWaferFabSettings(fileName);
}
static void Main(string[] args)
{
string inputDir = @"C:\CSSLWaferFab\Input\";
string outputDir = @"C:\CSSLWaferFab\Output\WaferFabSim\";
string parameters = @"FittedEPTParameters - 2019-8-1_4months.csv";
DateTime initialDateTime = new DateTime(2019, 8, 1);
Settings.WriteOutput = true;
Settings.FixSeed = true;
ShellModel WaferFabSim = new ShellModel(outputDir);
// Load WaferFab settings
AutoDataReader reader = new AutoDataReader(inputDir + @"CSVs\", inputDir + @"SerializedFiles\");
WaferFabSettings waferFabSettings = reader.ReadWaferFabSettings(parameters, true, true, DispatcherBase.Type.EPTOVERTAKING);
waferFabSettings.SampleInterval = 1 * 60 * 60; // seconds
waferFabSettings.LotStartsFrequency = 1; // hours
waferFabSettings.UseRealLotStartsFlag = true;
// MIVS Settings
//waferFabSettings.WIPTargets = reader.ReadWIPTargets(waferFabSettings.LotSteps, "WIPTargets.csv");
//waferFabSettings.MIVSjStepBack = 2;
//waferFabSettings.MIVSkStepAhead = 2;
// Read Initial Lots
WaferFabSim.ReadRealSnaphots(inputDir + @$ "SerializedFiles\RealSnapShots_2019-{initialDateTime.Month}-1_2019-{initialDateTime.Month + 1}-1_1h.dat");
waferFabSettings.InitialRealLots = WaferFabSim.RealSnapshotReader.RealSnapshots.Where(x => x.Time.Date == initialDateTime).OrderBy(x => x.Time).First().GetRealLots(1);
// Experiment settings
ExperimentSettings experimentSettings = new ExperimentSettings();
int count = waferFabSettings.InitialRealLots.Where(x => x.StartTime == null).Count();
experimentSettings.NumberOfReplications = 30;
experimentSettings.LengthOfReplication = 121 * 24 * 60 * 60; // seconds
experimentSettings.LengthOfWarmUp = 0 * 60 * 60; // seconds
// Connect settings
WaferFabSim.MyWaferFabSettings = waferFabSettings;
WaferFabSim.MyExperimentSettings = experimentSettings;
// Run simulation
WaferFabSim.RunSimulation();
// Report summary
SimulationReporter reporter = WaferFabSim.MySimulation.MakeSimulationReporter();
reporter.PrintSummaryToFile();
reporter.PrintSummaryToConsole();
}
/// <summary>
/// Serializes LotTraces. Gets the WorkCenterLotActivities from serialized files. Combines the individual activities from one lot into a trace.
/// </summary>
/// <param name="reader"></param>
/// <param name="workCenterLotAcitivitiesSerializedFile"></param>
public static void SerializeLotTraces(AutoDataReader reader, string filenameLotActivities, string filenameOutputFile)
{
if (reader.WaferFabSettings == null)
{
reader.ReadWaferFabSettings(@"FittedEPTParameters.csv", false, false, DispatcherBase.Type.EPTOVERTAKING);
}
reader.ReadWorkCenterLotActivities(filenameLotActivities, true);
reader.SerializeLotTraces(filenameOutputFile);
}
/// <summary>
/// Serializes LotStarts. Reads the LotTraces from serialized file, gets from all traces the starts and transfers this into LotStarts.
/// </summary>
/// <param name="reader"></param>
public static void SerializeLotStarts(AutoDataReader reader, string timeframe)
{
if (reader.WaferFabSettings == null)
{
reader.ReadWaferFabSettings(@"FittedEPTParameters.csv", false, false, DispatcherBase.Type.EPTOVERTAKING);
}
reader.LotTraces = Deserializer.DeserializeLotTraces(Path.Combine(reader.DirectorySerializedFiles, $"LotTraces_{timeframe}.dat"));
reader.GetLotStarts();
reader.SerializeLotStarts($"LotStarts_{timeframe}");
}
/// <summary>
/// Create a SelectionSet from a dataReader
/// </summary>
/// <param name="postGisFeatureClass"></param>
/// <param name="dataReader"></param>
public PostGisSelectionSet(PostGisFeatureClass postGisFeatureClass, AutoDataReader dataReader)
{
System.Diagnostics.Debug.WriteLine("NOT-Empty PostGisSelectionSet...");
m_featClass = postGisFeatureClass;
//oids.Add(1);
m_dr = dataReader;
if (dataReader != null)
{
while (dataReader.Read())
{
oids.Add((object)dataReader[PostGisConstants.idField]);
}
dataReader.Close();
}
}
static void Main(string[] args)
{
string inputDir = @"C:\Users\nx008314\OneDrive - Nexperia\Work\WaferFab\";
string outputDir = @"C:\CSSLWaferFab\";
Settings.Output = true;
Settings.FixSeed = true;
ShellModel WaferFabSim = new ShellModel(inputDir, outputDir);
// Load WaferFab settings
//ManualDataReader reader = new ManualDataReader(inputDir + "CSVs");
AutoDataReader reader = new AutoDataReader(inputDir + "Auto");
WaferFabSettings waferFabSettings = reader.ReadWaferFabSettings();
waferFabSettings.SampleInterval = 1 * 60 * 60; // seconds
waferFabSettings.LotStartsFrequency = 1; // hours
waferFabSettings.UseRealLotStartsFlag = true;
// Read Initial Lots
WaferFabSim.ReadRealSnaphots(inputDir + @"SerializedFiles\RealSnapshots_2019-12-1_2020-1-1_1h.dat");
waferFabSettings.InitialRealLots = WaferFabSim.RealSnapshotReader.RealSnapshots.First().RealLots;
// Experiment settings
ExperimentSettings experimentSettings = new ExperimentSettings();
experimentSettings.NumberOfReplications = 1;
experimentSettings.LengthOfReplication = 1 * 24 * 60 * 60; // seconds
experimentSettings.LengthOfWarmUp = 0 * 60 * 60; // seconds
// Connect settings
WaferFabSim.MyWaferFabSettings = waferFabSettings;
WaferFabSim.MyExperimentSettings = experimentSettings;
// Run simulation
WaferFabSim.RunSimulation();
// Report summary
SimulationReporter reporter = WaferFabSim.MySimulation.MakeSimulationReporter();
reporter.PrintSummaryToFile();
reporter.PrintSummaryToConsole();
}
public static void SerializeRealSnaphotsAll(AutoDataReader reader, int waferQtyThreshold)
{
if (reader.LotTraces == null)
{
reader.LotTraces = Deserializer.DeserializeLotTraces(Path.Combine(reader.DirectorySerializedFiles, "LotTraces_2019_2020.dat"));
}
DateTime start = reader.LotTraces.StartDate;
DateTime end = reader.LotTraces.EndDate;
DateTime from = new DateTime(start.Year, start.Month, start.Day, start.Hour, 0, 0, 0);
DateTime until = new DateTime(end.Year, end.Month, end.Day, end.Hour, 0, 0, 0);
TimeSpan frequency = new TimeSpan(1, 0, 0);
reader.ReadRealSnapshots(from, until, frequency, waferQtyThreshold);
reader.SerializeRealSnapshots($"{from.Year}-{from.Month}-{from.Day}_{until.Year}-{until.Month}-{until.Day}_{frequency.Hours}h");
}
static void LotArrivalAndDepartures()
{
string inputDir = @"C:\Users\nx008314\OneDrive - Nexperia\Work\WaferFab\Auto";
string outputDir = @"C:\Users\nx008314\OneDrive - Nexperia\Work\WaferFab\SerializedFiles";
AutoDataReader reader = new AutoDataReader(inputDir, outputDir);
reader.LotTraces = Deserializer.DeserializeLotTraces(Path.Combine(reader.DirectorySerializedFiles, $"LotTraces_2019_2020_2021.dat"));
using (StreamWriter writer = new StreamWriter(Path.Combine(outputDir, "LotStartsDeparturesFab_2019_2020_2021.txt")))
{
writer.WriteLine("LotID,ProductType,StartTime,EndTime,Status");
foreach (LotTraces.LotTrace trace in reader.LotTraces.All)
{
writer.WriteLine($"{trace.LotId},{trace.ProductType},{trace.StartDate},{trace.EndDate},{trace.Status}");
}
}
}
/// <summary>
/// Get a ISelectionSet from the feature class (Paolo, march 2007)
/// </summary>
/// <param name="QueryFilter"></param>
/// <param name="selType"></param>
/// <param name="selOption"></param>
/// <param name="selectionContainer"></param>
/// <returns></returns>
public ISelectionSet Select(IQueryFilter QueryFilter, esriSelectionType selType, esriSelectionOption selOption, IWorkspace selectionContainer)
{
log.enterFunc("Select");
if (log.IsDebugEnabled)
{
log.Debug(Helper.objectToString(QueryFilter) + "," + selType.ToString() + "," + selOption.ToString() + "," + Helper.objectToString(selectionContainer));
}
ISelectionSet retVal = null;
try
{
//retVal = new PostGisSelectionSet(this);
//2 cases, with null QueryFilter and without
if (QueryFilter == null)
{
retVal = new PostGisSelectionSet(this);
}
else
{
string sql = "";
string fields = "";
string where = "";
GeomHelper.aoQryToPostGisQry(QueryFilter, postGisLayer, out fields, out where);
AutoDataReader dr = postGisLayer.doQuery(fields, where);
retVal = new PostGisSelectionSet(this, dr);
}
}
finally
{
log.leaveFunc();
}
return(retVal as ISelectionSet);
}
public static void SerializeRealSnapshotsPerMonth(AutoDataReader reader, int waferQtyThreshold)
{
if (reader.LotTraces == null)
{
reader.LotTraces = Deserializer.DeserializeLotTraces(Path.Combine(reader.DirectorySerializedFiles, "LotTraces_2019_2020.dat"));
}
DateTime start = reader.LotTraces.StartDate;
DateTime end = reader.LotTraces.EndDate;
DateTime from = new DateTime(start.Year, start.Month, start.Day, start.Hour, 0, 0, 0);
DateTime until = new DateTime(start.AddMonths(1).Year, start.AddMonths(1).Month, 1, 0, 0, 0, 0); // Until first of next month
TimeSpan frequency = new TimeSpan(1, 0, 0);
while (until < end.AddMonths(1))
{
reader.ReadRealSnapshots(from, until, frequency, waferQtyThreshold);
reader.SerializeRealSnapshots($"{from.Year}-{from.Month}-{from.Day}_{until.Year}-{until.Month}-{until.Day}_{frequency.Hours}h");
from = until;
until = until.AddMonths(1);
}
}
static void Main(string[] args)
{
string inputDirectory = @"C:\CSSLWaferFab\Input\WSC2021paper";
string outputDirectory = @"C:\CSSLWaferFab\Output\WSC2021paper";
string eptParameterFile = @"FittedEPTParameters - 2019-6-1.csv";
List <string> workcenters = new List <string> {
"PHOTOLITH", "FURNACING", "DRY ETCH"
};
List <string> SOvsLDO = new List <string> {
"SO", "LDO"
};
//List<string> SOvsLDO = new List<string> { "LDO"};
foreach (string wc in workcenters)
{
WaferFabSettings waferFabSettings = Deserializer.DeserializeWaferFabSettings(Path.Combine(inputDirectory, "SerializedFiles", $"WaferFabSettings_{wc}_WithLotStarts.dat"));
foreach (string overtaking in SOvsLDO)
{
bool lotStepOvertaking = overtaking == "SO" ? false : true;
#region Initializing simulation
Simulation simulation = new Simulation(wc, outputDirectory);
#endregion
#region Experiment settings
simulation.MyExperiment.NumberOfReplications = 10;
simulation.MyExperiment.LengthOfReplication = 60 * 60 * 24 * 91; // September and October
simulation.MyExperiment.LengthOfWarmUp = 60 * 60 * 24 * 30;
DateTime initialDateTime = new DateTime(2019, 08, 01);
#endregion
#region WaferFab settings
EPTDistributionReader distributionReader = new EPTDistributionReader(Path.Combine(inputDirectory, "CSVs"), waferFabSettings.WorkCenters, waferFabSettings.LotStepsPerWorkStation);
waferFabSettings.WCServiceTimeDistributions = distributionReader.GetServiceTimeDistributions(eptParameterFile);
waferFabSettings.WCOvertakingDistributions = distributionReader.GetOvertakingDistributions(lotStepOvertaking);
waferFabSettings.WCDispatcherTypes[wc] = DispatcherBase.Type.EPTOVERTAKING;
#endregion
#region Make starting lots
AutoDataReader dataReader = new AutoDataReader(Path.Combine(inputDirectory, "Auto"), Path.Combine(inputDirectory, "SerializedFiles"));
#endregion
#region Building the model
WaferFab waferFab = new WaferFab(simulation.MyModel, "WaferFab", new ConstantDistribution(60 * 60 * 24), initialDateTime);
WorkCenter workCenter = new WorkCenter(waferFab, $"WorkCenter_{wc}", waferFabSettings.WCServiceTimeDistributions[wc], waferFabSettings.LotStepsPerWorkStation[wc]);
// Connect workcenter to WIPDependentDistribution
EPTDistribution distr = (EPTDistribution)waferFabSettings.WCServiceTimeDistributions[wc];
distr.WorkCenter = workCenter;
EPTOvertakingDispatcher dispatcher = new EPTOvertakingDispatcher(workCenter, workCenter.Name + "_EPTOvertakingDispatcher", waferFabSettings.WCOvertakingDistributions[wc]);
workCenter.SetDispatcher(dispatcher);
// Connect workcenter to OvertakingDistribution
waferFabSettings.WCOvertakingDistributions[wc].WorkCenter = workCenter;
waferFab.AddWorkCenter(workCenter.Name, workCenter);
// Sequences
foreach (var sequence in waferFabSettings.Sequences)
{
waferFab.AddSequence(sequence.Key, sequence.Value);
}
// LotSteps
waferFab.LotSteps = waferFab.Sequences.Select(x => x.Value).Select(x => x.GetCurrentStep(0)).ToDictionary(x => x.Name);
// LotGenerator
waferFab.SetLotGenerator(new LotGenerator(waferFab, "LotGenerator", new ConstantDistribution(60), true));
// Add lotstarts
waferFab.LotStarts = waferFabSettings.LotStarts;
// Add observers
LotOutObserver lotOutObserver = new LotOutObserver(simulation, wc + "_" + overtaking + "LotOutObserver");
dispatcher.Subscribe(lotOutObserver);
OptimiserObserver optimiserObserver = new OptimiserObserver(simulation, "TotalQueueObserver");
workCenter.Subscribe(optimiserObserver);
#endregion
#region Read initial lots
//RealSnapshotReader reader = new RealSnapshotReader();
//List<RealSnapshot> realSnapshots = reader.Read(Path.Combine(inputDirectory, "SerializedFiles", reader.GetRealSnapshotString(initialDateTime)), 1);
//RealSnapshot realSnapShot = realSnapshots.Where(x => x.Time == initialDateTime).First();
//List<string> lotSteps = workCenter.LotSteps.Select(x => x.Name).ToList();
//List<RealLot> initialRealLots = realSnapShot.GetRealLots(1).Where(x => lotSteps.Contains(x.IRDGroup)).ToList();
//List<Lot> initialLots = initialRealLots.Select(x => x.ConvertToLotArea(0, waferFabSettings.Sequences, initialDateTime)).ToList();
//waferFab.InitialLots = initialLots;
#endregion
simulation.Run();
#region Reporting
SimulationReporter reporter = simulation.MakeSimulationReporter();
reporter.PrintSummaryToConsole();
#endregion
}
}
}
static void SnapshotsWorksstationQueueLenthsJeroen()
{
/// //////////////////////////////////////////////
/// SnapShots Workstation Queue Lengths //////////
/*
* DateTime date = new DateTime(2019, 6, 1);
* int monthsToEvaluate = 12;
*
* string inputDir = @"C:\CSSLWaferFab\Input\";
*
* string outputDir = @"C:\CSSLWaferFab\Output";
*
* string parameters = @"FittedEPTParameters - 2019-06-01.csv";
*
* AutoDataReader autoDataReader = new AutoDataReader(inputDir + @"CSVs\", inputDir + @"SerializedFiles\");
* WaferFabSettings waferFabSettings = autoDataReader.ReadWaferFabSettings(parameters, true, false);
*
* List<string> workCenters = new List<string>();
* foreach (string workCenter in waferFabSettings.WorkCenters)
* {
* workCenters.Add(workCenter);
* }
*
* // Write headers
* StreamWriter writer = new StreamWriter(Path.Combine(outputDir, "Snapshots", $"Snapshots Workcenter - Complete - 06-2019.txt"));
* writer.Write("Time,");
* foreach (string workCenter in workCenters)
* {
* if (workCenter != workCenters.Last())
* {
* writer.Write($"{workCenter},");
* }
* else
* {
* writer.Write($"{workCenter}\n");
* }
* }
*
* RealSnapshotReader realSnapshotReader = new RealSnapshotReader();
* for (int j = 0; j < monthsToEvaluate; j++)
* {
* DateTime n = date.AddMonths(j);
* DateTime m = date.AddMonths(j + 1);
*
* string filename = inputDir + @$"SerializedFiles\RealSnapShots_{n.Year}-{n.Month}-{n.Day}_{m.Year}-{m.Month}-{m.Day}_1h.dat";
* realSnapshotReader.Read(filename, 1);
*
* List<RealSnapshot> realSnaphshots = new List<RealSnapshot>();
* if (j == 0)
* {
* realSnaphshots = realSnapshotReader.RealSnapshots;
* }
* else
* {
* realSnaphshots = realSnapshotReader.RealSnapshots.Skip(1).ToList();
* }
*
* // Write Data
* foreach (RealSnapshot realSnapshot in realSnaphshots)
* {
* writer.Write($"{realSnapshot.Time},");
* foreach (string workCenter in workCenters)
* {
* if (workCenter != workCenters.Last())
* {
* int count = realSnapshot.RealLots.Where(x => x.LotActivity.WorkStation == workCenter).Count();
* writer.Write($"{count},");
* }
* else
* {
* int count = realSnapshot.RealLots.Where(x => x.LotActivity.WorkStation == workCenter).Count();
* writer.Write($"{count}\n");
* }
* }
* }
* }
*
* writer.Close();
*/
/// //////////////////////////////////////////////
/// SnapShots IRD Queue Lengths //////////////////
DateTime date = new DateTime(2019, 6, 1);
int monthsToEvaluate = 12;
string inputDir = @"C:\CSSLWaferFab\Input\";
string outputDir = @"C:\CSSLWaferFab\Output";
string parameters = @"FittedEPTParameters - 2019-06-01.csv";
AutoDataReader autoDataReader = new AutoDataReader(inputDir + @"CSVs\", inputDir + @"SerializedFiles\");
WaferFabSettings waferFabSettings = autoDataReader.ReadWaferFabSettings(parameters, true, false);
List <string> orderedLotSteps = new List <string>();
foreach (var step in waferFabSettings.LotSteps.OrderBy(x => x.Value.Id))
{
orderedLotSteps.Add(step.Key);
}
//Write headers
StreamWriter writer = new StreamWriter(Path.Combine(outputDir, "Snapshots", $"Snapshots IRD Wafers - {date.Year}-{date.Month}-{date.Day}.txt"));
writer.Write("Time,");
foreach (string lotStep in orderedLotSteps)
{
if (lotStep != orderedLotSteps.Last())
{
writer.Write($"{lotStep},");
}
else
{
writer.Write($"{lotStep}\n");
}
}
RealSnapshotReader realSnapshotReader = new RealSnapshotReader();
for (int j = 0; j < monthsToEvaluate; j++)
{
DateTime n = date.AddMonths(j);
DateTime m = date.AddMonths(j + 1);
string filename = inputDir + @$ "SerializedFiles\RealSnapShots_{n.Year}-{n.Month}-{n.Day}_{m.Year}-{m.Month}-{m.Day}_1h.dat";
realSnapshotReader.Read(filename, 1);
List <RealSnapshot> realSnaphshots = new List <RealSnapshot>();
if (j == 0)
{
realSnaphshots = realSnapshotReader.RealSnapshots;
}
else
{
realSnaphshots = realSnapshotReader.RealSnapshots.Skip(1).ToList();
}
//Write Data
foreach (RealSnapshot realSnapshot in realSnaphshots)
{
writer.Write($"{realSnapshot.Time},");
foreach (string lotStep in orderedLotSteps)
{
if (lotStep != orderedLotSteps.Last())
{
if (realSnapshot.LotSteps.Contains(lotStep))
{
List <RealLot> realLots = realSnapshot.RealLots.Where(x => x.IRDGroup == lotStep).ToList();
int nrOfWafers = 0;
for (int k = 0; k < realLots.Count(); k++)
{
nrOfWafers += realLots[k].Qty;
}
writer.Write($"{nrOfWafers},");
}
else
{
writer.Write("0,");
}
}
else
{
if (realSnapshot.LotSteps.Contains(lotStep))
{
List <RealLot> realLots = realSnapshot.RealLots.Where(x => x.IRDGroup == lotStep).ToList();
int nrOfWafers = 0;
for (int k = 0; k < realLots.Count(); k++)
{
nrOfWafers += realLots[k].Qty;
}
writer.Write($"{nrOfWafers}\n");
}
else
{
writer.Write("0\n");
}
}
}
}
}
writer.Close();
/// //////////////////////////////////////////////
/// SnapShots IRD Queue Lengths //////////////////
/*
* DateTime i = new DateTime(2019, 10, 1);
*
* string inputDir = @"E:\OneDrive - Nexperia\CSSLWaferFab\Input\";
*
* string outputDir = $@"C:\CSSLWaferFab\Output";
*
*
* AutoDataReader autoDataReader = new AutoDataReader(inputDir + @"CSVs\", inputDir + @"SerializedFiles\");
* WaferFabSettings waferFabSettings = autoDataReader.ReadWaferFabSettings(true, false);
* List<string> orderedLotSteps = new List<string>();
* foreach (var step in waferFabSettings.LotSteps.OrderBy(x => x.Value.Id))
* {
* orderedLotSteps.Add(step.Key);
* }
*
* // Write headers
* StreamWriter writer = new StreamWriter(Path.Combine(outputDir, "Snapshots", $"Snapshots IRD Lots - {i.Year}-{i.Month}-{i.Day}.txt"));
* writer.Write("Time,");
* foreach (string lotStep in orderedLotSteps)
* {
* if (lotStep != orderedLotSteps.Last())
* {
* writer.Write($"{lotStep},");
* }
* else
* {
* writer.Write($"{lotStep}\n");
* }
* }
*
* RealSnapshotReader realSnapshotReader = new RealSnapshotReader();
* for (int j = 0; j < 2; j++)
* {
* string filename = inputDir + @$"SerializedFiles\RealSnapShots_{i.Year}-{i.Month + j}-{i.Day}_{i.Year}-{i.Month + 1 + j}-{i.Day}_1h.dat";
* realSnapshotReader.Read(filename, 1);
*
* List<RealSnapshot> realSnaphshots = new List<RealSnapshot>();
* if (j == 0)
* {
* realSnaphshots = realSnapshotReader.RealSnapshots;
* }
* else
* {
* realSnaphshots = realSnapshotReader.RealSnapshots.Skip(1).ToList();
* }
*
* // Write Data
* foreach (RealSnapshot realSnapshot in realSnaphshots)
* {
* writer.Write($"{realSnapshot.Time},");
* foreach (string lotStep in orderedLotSteps)
* {
* if (lotStep != orderedLotSteps.Last())
* {
* if (realSnapshot.LotSteps.Contains(lotStep))
* {
* int count = realSnapshot.RealLots.Where(x => x.IRDGroup == lotStep).Count();
* writer.Write($"{count},");
* }
* else
* {
* writer.Write("0,");
* }
* }
* else
* {
* if (realSnapshot.LotSteps.Contains(lotStep))
* {
* int count = realSnapshot.RealLots.Where(x => x.IRDGroup == lotStep).Count();
* writer.Write($"{count}\n");
* }
* else
* {
* writer.Write("0\n");
* }
* }
* }
* }
* }
*
* writer.Close();
*
*
*
* /// ///////////////////////////////////////////////////
* /// Gamma analysis ///////////////////////////////
* /*
* bool write = true;
*
* GammaDistribution gammaDistribution = new GammaDistribution(90, 72900);
* double alpha = 0.11;
* double beta = 0.001235;
*
* Console.WriteLine("{0}, {1}", gammaDistribution.Alpha, gammaDistribution.Beta);
* List<double> values = new List<double>();
* double sumx = 0;
* double sumxx = 0;
* double sumw = 0;
*
* for (int i = 0; i < 1000000; i++)
* {
* double value = gammaDistribution.Next();
* values.Add(value);
* sumx += value;
* sumxx += value * value;
* sumw += 1;
* }
*
* double mean = sumx / sumw;
* double variance = sumxx / sumw - sumx / sumw * sumx / sumw;
* double stdev = Math.Sqrt(variance);
*
* Console.WriteLine("{0}, {1}, {2}", mean, variance, stdev);
* Console.WriteLine("{0}, {1}", gammaDistribution.Alpha, gammaDistribution.Beta);
* if (write)
* {
* using (StreamWriter writer = new StreamWriter(@$"E:\OneDrive - Nexperia\OUTPUT\Python\Gamma Test\Alpha = {alpha}, Beta = {beta}.txt"))
* {
* writer.WriteLine("Gamma rvs");
*
* foreach (double i in values)
* {
* writer.WriteLine(i);
* }
* }
* }
*/
/// ///////////////////////////////////////////////////
/// Read Queue lengths ///////////////////////////////
/*
* DateTime initialDateTime = new DateTime(2019, 4, 1);
*
* DateTime finalDateTime = new DateTime(2022, 4, 1);
*
* string DirectorySerializedFiles = @"E:\OneDrive - Nexperia\CSSLWaferFab\Input\SerializedFiles";
*
* string outputDirectory = $@"C:\CSSLWaferFab\LotActivities\{initialDateTime.ToString("yyyy-MM-dd")}";
*
* List<WorkCenterLotActivities> workCenterLotActivities = Deserializer.DeserializeWorkCenterLotActivities(Path.Combine(DirectorySerializedFiles, "WorkCenterLotActivities_2019_2020.dat"));
*
* //string wc = "PHOTOLITH";
*
* List<string> workCenters = new List<string>()
* {"BACKGRIND", "BATCH UP", "CMP", "DICE", "DRY ETCH", "ELEC TEST", "EVAPORATION", "FURNACING", "IMPLANT",
* "INSPECTION", "LPCVD", "MERCURY", "NITRIDE DEP", "OFF LINE INK", "PACK", "PHOTOLITH", "PROBE", "REPORTING",
* "SAMPLE TEST", "SPUTTERING", "WET ETCH"};
*
*
* foreach (string wc in workCenters)
* {
* List<Tuple<DateTime, int>> queueLengths = workCenterLotActivities.Where(x => x.WorkCenter == wc).First()
* .WIPTrace.Where(x => x.Item1 >= initialDateTime && x.Item1 <= finalDateTime).OrderBy(x => x.Item1).ToList();
*
* // Write all results to a text file
* using (StreamWriter writer = new StreamWriter(Path.Combine(outputDirectory, $"{wc}_QueueLength.txt")))
* {
* writer.WriteLine("Time,QueueLength");
*
* foreach (Tuple<DateTime, int> queueLength in queueLengths)
* {
* writer.WriteLine(queueLength.Item1 + "," + queueLength.Item2);
* }
* }
* }
*/
}
static void Main(string[] args)
{
List <DateTime> DateTimes = ReadDateTimes(@"C:\CSSLWaferFab\Input\WIPBalanceWeights\DateTimes.csv");
int jStepBack = 0;
int kStepAhead = 1;
string inputDir = @"C:\CSSLWaferFab\Input\";
string eptParameterFile = @"FittedEPTParameters - 2019-06-01.csv";
// Get WaferFabSettings
AutoDataReader reader = new AutoDataReader(inputDir + @"CSVs\", inputDir + @"SerializedFiles\");
WaferFabSettings waferFabSettings = reader.ReadWaferFabSettings(eptParameterFile, false, false, DispatcherBase.Type.MIVS);
waferFabSettings.WIPTargets = reader.ReadWIPTargets(waferFabSettings.LotSteps, "WIPTargets.csv");
// Get all lots from snapshot
LotTraces lotTraces = Deserializer.DeserializeLotTraces(inputDir + @"SerializedFiles\LotTraces_2019_2020_2021.dat");
foreach (DateTime time in DateTimes)
{
RealSnapshot realSnapshot = lotTraces.GetWIPSnapshot(time, 0);
List <Lot> lots = realSnapshot.GetRealLots(0).Select(x => x.ConvertToLot(0, waferFabSettings.Sequences, false, time)).Where(x => x != null).ToList();
// Construct current WIP levels and WIP targets
Dictionary <string, int> WIPlevels = realSnapshot.WIPlevelsInWafers;
Dictionary <LotStep, double> WIPtargets = waferFabSettings.WIPTargets;
// Construct weights per lot
Dictionary <Lot, double> weights = new Dictionary <Lot, double>();
foreach (Lot lot in lots)
{
double weight = 0.0;
for (int relStep = -jStepBack; relStep <= 0; relStep++)
{
if (lot.HasRelativeStep(relStep))
{
LotStep step = lot.GetRelativeStep(relStep);
if (WIPlevels.ContainsKey(step.Name))
{
weight += WIPlevels[step.Name] - WIPtargets[step];
}
else // WIP level of step is not know in snapshot, so it has to be 0
{
weight -= WIPtargets[step];
}
}
}
for (int relStep = 1; relStep <= kStepAhead; relStep++)
{
if (lot.HasRelativeStep(relStep))
{
LotStep step = lot.GetRelativeStep(relStep);
if (WIPlevels.ContainsKey(step.Name))
{
weight += WIPtargets[step] - WIPlevels[step.Name];
}
else // WIP level of step is not know in snapshot, so it has to be 0
{
weight += WIPtargets[step];
}
}
}
weights.Add(lot, weight);
}
WriteWeightsToCSV(weights, time);
}
}
static void Main(string[] args)
{
List <string> workcenters = new List <string>()
{
"BACKGRIND", "BATCH UP", "CMP", "DICE", "DRY ETCH", "ELEC TEST", "EVAPORATION", "FURNACING", "IMPLANT",
"INSPECTION", "LPCVD", "MERCURY", "NITRIDE DEP", "OFF LINE INK", "PACK", "PHOTOLITH", "PROBE", "REPORTING",
"SAMPLE TEST", "SPUTTERING", "WET ETCH"
};
DateTime initialDateTime = new DateTime(2019, 10, 1);
string inputDirectory = @"C:\CSSLWaferFab\Input";
string outputDirectory = @"C:\CSSLWaferFab\Output\WaferFabArea";
string eptParameterFile = @"FittedEPTParameters - 2019-6-1.csv";
RealSnapshotReader reader = new RealSnapshotReader();
List <RealSnapshot> realSnapshots = reader.Read(Path.Combine(inputDirectory, "SerializedFiles", reader.GetRealSnapshotString(initialDateTime)), 1);
RealSnapshot realSnapShot = realSnapshots.Where(x => x.Time == initialDateTime).First();
//workcenters = new List<string>() {"INSPECTION"};
foreach (string workcenter in workcenters)
{
#region Parameters
string wc = workcenter;
bool isFitted = false; // true = fitted, false = optimised
bool lotStepOvertaking = true;
#endregion
#region Initializing simulation
Simulation simulation = new Simulation(wc, outputDirectory);
#endregion
#region Experiment settings
simulation.MyExperiment.NumberOfReplications = 30;
DateTime finalDateTime = new DateTime(2019, initialDateTime.Month + 2, 1);
simulation.MyExperiment.LengthOfReplication = (finalDateTime - initialDateTime).TotalSeconds; // Number of seconds between two months
simulation.MyExperiment.LengthOfWarmUp = 60 * 60 * 24 * 0;
#endregion
#region WaferFab settings
WaferFabSettings waferFabSettings = Deserializer.DeserializeWaferFabSettings(Path.Combine(inputDirectory, "SerializedFiles", $"WaferFabSettings_{wc}_WithLotStarts.dat"));
EPTDistributionReader distributionReader = new EPTDistributionReader(Path.Combine(inputDirectory, "CSVs"), waferFabSettings.WorkCenters, waferFabSettings.LotStepsPerWorkStation);
waferFabSettings.WCServiceTimeDistributions = distributionReader.GetServiceTimeDistributions(eptParameterFile);
waferFabSettings.WCOvertakingDistributions = distributionReader.GetOvertakingDistributions(lotStepOvertaking);
waferFabSettings.WCDispatcherTypes[workcenter] = DispatcherBase.Type.EPTOVERTAKING;
#endregion
#region Make starting lots
AutoDataReader dataReader = new AutoDataReader(Path.Combine(inputDirectory, "Auto"), Path.Combine(inputDirectory, "SerializedFiles"));
#endregion
#region Building the model
WaferFab waferFab = new WaferFab(simulation.MyModel, "WaferFab", new ConstantDistribution(60 * 60 * 24), initialDateTime);
WorkCenter workCenter = new WorkCenter(waferFab, $"WorkCenter_{wc}", waferFabSettings.WCServiceTimeDistributions[wc], waferFabSettings.LotStepsPerWorkStation[wc]);
// Connect workcenter to WIPDependentDistribution
EPTDistribution distr = (EPTDistribution)waferFabSettings.WCServiceTimeDistributions[wc];
distr.WorkCenter = workCenter;
EPTOvertakingDispatcher dispatcher = new EPTOvertakingDispatcher(workCenter, workCenter.Name + "_EPTOvertakingDispatcher", waferFabSettings.WCOvertakingDistributions[wc]);
workCenter.SetDispatcher(dispatcher);
// Connect workcenter to OvertakingDistribution
waferFabSettings.WCOvertakingDistributions[wc].WorkCenter = workCenter;
waferFab.AddWorkCenter(workCenter.Name, workCenter);
// Sequences
foreach (var sequence in waferFabSettings.Sequences)
{
waferFab.AddSequence(sequence.Key, sequence.Value);
}
// LotSteps
waferFab.LotSteps = waferFab.Sequences.Select(x => x.Value).Select(x => x.GetCurrentStep(0)).ToDictionary(x => x.Name);
// LotGenerator
waferFab.SetLotGenerator(new LotGenerator(waferFab, "LotGenerator", new ConstantDistribution(60), true));
// Add lotstarts
waferFab.LotStarts = waferFabSettings.LotStarts;
// Add initial lots
List <RealLot> initialRealLots = realSnapShot.GetRealLots(1).Where(x => x.LotActivity.WorkStation == wc).ToList();
waferFab.InitialLots = initialRealLots.Select(x => x.ConvertToLotArea(0, waferFabSettings.Sequences, initialDateTime)).ToList();
// Add observers
LotOutObserver lotOutObserver = new LotOutObserver(simulation, wc + "_LotOutObserver");
dispatcher.Subscribe(lotOutObserver);
TotalQueueObserver totalQueueObserver = new TotalQueueObserver(simulation, wc + "_TotalQueueObserver");
workCenter.Subscribe(totalQueueObserver);
#endregion
simulation.Run();
#region Reporting
SimulationReporter reporter = simulation.MakeSimulationReporter();
reporter.PrintSummaryToConsole();
#endregion
}
}
public static void WriteLotActivitiesWithEPTsToCSV(AutoDataReader reader, string serializedLotTracesFile, string filenameCSVOutput)
{
reader.LotTraces = Deserializer.DeserializeLotTraces(Path.Combine(reader.DirectorySerializedFiles, serializedLotTracesFile));
reader.WriteLotActivitiesToCSV(filenameCSVOutput);
}
