public void AddResult(Dictionary <WIPDepDistParameters, Tuple <double, double> > results, Dictionary <string, Distribution> parameters, Tuple <double, double> result)
{
EPTDistribution dist = (EPTDistribution)parameters.First().Value;
WIPDepDistParameters x = dist.Par;
results.Add(x, result);
}
public WaferAreaSim(string wc, string eptParameterFile, string inputDirectory, string outputDirectory, DateTime initialDateTime, Optimiser optimiser, bool useInitialLots = false)
{
this.wc = wc;
this.inputDirectory = inputDirectory;
this.outputDirectory = outputDirectory;
this.initialDateTime = initialDateTime;
this.optimiser = optimiser;
this.useInitialLots = useInitialLots;
#region WaferFab settings
waferFabSettings = Deserializer.DeserializeWaferFabSettings(Path.Combine(inputDirectory, "SerializedFiles", $"WaferFabSettings_{wc}_WithLotStarts.dat"));
distributionReader = new EPTDistributionReader(Path.Combine(inputDirectory, "CSVs"), waferFabSettings.WorkCenters, waferFabSettings.LotStepsPerWorkStation);
// Get initial parameters
waferFabSettings.WCServiceTimeDistributions = distributionReader.GetServiceTimeDistributions(eptParameterFile);
EPTDistribution initialDist = (EPTDistribution)waferFabSettings.WCServiceTimeDistributions[wc];
InitialParameters = new Dictionary <string, Distribution> {
{ wc, optimiser.CheckInitialDistBounds(initialDist) }
};
waferFabSettings.WCOvertakingDistributions = distributionReader.GetOvertakingDistributions();
#endregion
if (useInitialLots)
{
initialLots = optimiser.GetInitialLots(wc, inputDirectory, outputDirectory, initialDateTime, waferFabSettings);
}
}
/// <summary>
/// Write current and best parameter configurations to file.
/// </summary>
public void WriteFinalSolutions(Dictionary <string, Distribution> currentPar, Tuple <double, double> currentRes,
Dictionary <string, Distribution> bestPar, Tuple <double, double> bestRes, string wc)
{
using (StreamWriter writer = new StreamWriter(Path.Combine(outputDirectory, $"{wc}_best_parameters.txt")))
{
writer.WriteLine("Parameters,LBWIP,UBWIP,Tmin,Tmax,Tdecay,Cmin,Cmax,Cdecay,AverageQL,StdQL");
EPTDistribution dist = (EPTDistribution)currentPar.First().Value;
WIPDepDistParameters par = dist.Par;
writer.WriteLine($"Current,{par.LBWIP},{par.UBWIP},{par.Tmin},{par.Tmax},{par.Tdecay},{par.Cmin},{par.Cmax},{par.Cdecay},{currentRes.Item1},{currentRes.Item2}");
dist = (EPTDistribution)bestPar.First().Value;
par = dist.Par;
writer.WriteLine($"Best,{par.LBWIP},{par.UBWIP},{par.Tmin},{par.Tmax},{par.Tdecay},{par.Cmin},{par.Cmax},{par.Cdecay},{bestRes.Item1},{bestRes.Item2}");
}
}
public Dictionary <string, Distribution> CopyParameters(Dictionary <string, Distribution> parameters)
{
EPTDistribution dist = (EPTDistribution)parameters.First().Value;
WIPDepDistParameters x = dist.Par;
WIPDepDistParameters pars = new WIPDepDistParameters
{
LBWIP = x.LBWIP,
UBWIP = x.UBWIP,
Tmin = x.Tmin,
Tmax = x.Tmax,
Tdecay = x.Tdecay,
Cmin = x.Cmin,
Cmax = x.Cmax,
Cdecay = x.Cdecay
};
Dictionary <string, Distribution> copiedParameters = new Dictionary <string, Distribution>
{
{ wc, new EPTDistribution(pars) }
};
return(copiedParameters);
}
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 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 Dictionary <string, Distribution> GenerateNeighbour(Dictionary <string, Distribution> currentPar, double temp)
{
EPTDistribution dist = (EPTDistribution)currentPar.First().Value;
WIPDepDistParameters x = dist.Par;
WIPDepDistParameters par = new WIPDepDistParameters {
WorkCenter = wc
};
UniformDistribution parDist = new UniformDistribution(0, Parameter.TotalWeight);
double u = parDist.Next();
// x is the original parameter set (input), par is a neighbouring parameter set
// Change one parameter based on a probability
if (isInRange("LBWIP", u))
{
par.LBWIP = (int)Math.Max(1, newValue("LBWIP", x.LBWIP));
}
else
{
par.LBWIP = x.LBWIP;
}
if (isInRange("UBWIP", u))
{
par.UBWIP = (int)Math.Max(1, newValue("UBWIP", x.UBWIP));
}
else
{
par.UBWIP = x.UBWIP;
}
if (isInRange("Tmin", u))
{
par.Tmin = newValue("Tmin", x.Tmin);
}
else
{
par.Tmin = x.Tmin;
}
if (isInRange("Tmax", u))
{
par.Tmax = newValue("Tmax", x.Tmax);
}
else
{
par.Tmax = x.Tmax;
}
if (isInRange("Tdecay", u))
{
par.Tdecay = newValue("Tdecay", x.Tdecay);
}
else
{
par.Tdecay = x.Tdecay;
}
if (isInRange("Cmin", u))
{
par.Cmin = newValue("Cmin", x.Cmin);
}
else
{
par.Cmin = x.Cmin;
}
if (isInRange("Cmax", u))
{
par.Cmax = newValue("Cmax", x.Cmax);
}
else
{
par.Cmax = x.Cmax;
}
if (isInRange("Cdecay", u))
{
par.Cdecay = newValue("Cdecay", x.Cdecay);
}
else
{
par.Cdecay = x.Cdecay;
}
Dictionary <string, Distribution> neighbour = new Dictionary <string, Distribution> {
{ wc, new EPTDistribution(par) }
};
return(neighbour);
bool isInRange(string parName, double u)
{
Parameter parameter = ParConfig[parName];
double pLower = parameter.CumulativeWeight - parameter.Weight;
double pUpper = parameter.CumulativeWeight;
if (u > pLower && u <= pUpper)
{
return(true);
}
else
{
return(false);
}
}
double newValue(string parName, double value)
{
// Use Min-max feature scaling to determine the half width size of the new value
// Large range at high temps (50%), small range at low temps (10%)
double halfWidth = (0.5 - 0.1) * temp / maxTemp + 0.1;
Parameter parameter = ParConfig[parName];
double lowerBound = Math.Max(parameter.LowerBound, value - value * halfWidth);
double upperBound = Math.Min(parameter.UpperBound, value + value * halfWidth);
UniformDistribution valueDist = new UniformDistribution(lowerBound, upperBound);
return(valueDist.Next());
}
}
public EPTDistribution CheckInitialDistBounds(EPTDistribution dist)
{
WIPDepDistParameters x = dist.Par;
// For each initial value, check if it is within bounds. If not, set to closest bound
if (x.Tmin < ParConfig["Tmin"].LowerBound)
{
x.Tmin = ParConfig["Tmin"].LowerBound;
}
else if (x.Tmin > ParConfig["Tmin"].UpperBound)
{
x.Tmin = ParConfig["Tmin"].UpperBound;
}
if (x.Tmax < ParConfig["Tmax"].LowerBound)
{
x.Tmax = ParConfig["Tmax"].LowerBound;
}
else if (x.Tmax > ParConfig["Tmax"].UpperBound)
{
x.Tmax = ParConfig["Tmax"].UpperBound;
}
if (x.Tdecay < ParConfig["Tdecay"].LowerBound)
{
x.Tdecay = ParConfig["Tdecay"].LowerBound;
}
else if (x.Tdecay > ParConfig["Tdecay"].UpperBound)
{
x.Tdecay = ParConfig["Tdecay"].UpperBound;
}
if (x.Cmin < ParConfig["Cmin"].LowerBound)
{
x.Cmin = ParConfig["Cmin"].LowerBound;
}
else if (x.Cmin > ParConfig["Cmin"].UpperBound)
{
x.Cmin = ParConfig["Cmin"].UpperBound;
}
if (x.Cmax < ParConfig["Cmax"].LowerBound)
{
x.Cmax = ParConfig["Cmax"].LowerBound;
}
else if (x.Cmax > ParConfig["Cmax"].UpperBound)
{
x.Cmax = ParConfig["Cmax"].UpperBound;
}
if (x.Cdecay < ParConfig["Cdecay"].LowerBound)
{
x.Cdecay = ParConfig["Cdecay"].LowerBound;
}
else if (x.Cdecay > ParConfig["Cdecay"].UpperBound)
{
x.Cdecay = ParConfig["Cdecay"].UpperBound;
}
EPTDistribution newDist = new EPTDistribution(x);
return(newDist);
}
public Tuple <double, double> RunSim(Dictionary <string, Distribution> dict)
{
EPTDistribution dist = (EPTDistribution)dict.First().Value;
WIPDepDistParameters x = dist.Par;
waferFabSettings.WCServiceTimeDistributions = new Dictionary <string, Distribution> {
{ wc, new EPTDistribution(x) }
};
#region Initializing simulation
Simulation simulation = new Simulation("CSSLWaferFabArea", outputDirectory);
#endregion
#region Experiment settings
simulation.MyExperiment.NumberOfReplications = 10;
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 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
if (useInitialLots)
{
List <Lot> initialLotsDeepCopy = initialLots.ConvertAll(x => new Lot(x));
waferFab.InitialLots = initialLotsDeepCopy;
}
// Add observers
OptimiserObserver optimiserObs = new OptimiserObserver(simulation, wc + "_TotalQueueObserver");
workCenter.Subscribe(optimiserObs); // Total queue for workcenter
#endregion
simulation.Run();
#region Reporting
SimulationReporter reporter = simulation.MakeSimulationReporter();
reporter.PrintSummaryToConsole();
#endregion
Tuple <double, double> results = new Tuple <double, double>(optimiserObs.QueueLengthStatistic.Average(), optimiserObs.QueueLengthStatistic.StandardDeviation());
return(results);
}
