/// <summary>
/// Clean code i guess...
/// </summary>
static private SimulationCase GenerateCase(SimulationSystem system, Inventory inventory, int Day)
{
int R1 = rnd.Next(1, 100);
int CurrentDemand = CalculateRandomValue(system.DemandDistribution, R1);
int CarryOverShortage = 0;
if (inventory.CurrentOrder != null && inventory.CurrentOrder.DueDate == Day)
{
CarryOverShortage = Math.Min(inventory.Quantity, 0) * -1;
inventory.Quantity = Math.Max(inventory.Quantity, 0) + inventory.CurrentOrder.Quantity;
inventory.CurrentOrder = null;
}
SimulationCase Case = new SimulationCase()
{
Day = Day + 1,
Cycle = (Day / system.ReviewPeriod) + 1,
BeginningInventory = Math.Max(0, inventory.Quantity),
DayWithinCycle = (Day % system.ReviewPeriod) + 1,
RandomDemand = R1,
Demand = CurrentDemand,
EndingInventory = Math.Max(0, inventory.Quantity - CurrentDemand - CarryOverShortage),
ShortageQuantity = Math.Max(0, CarryOverShortage + CurrentDemand - inventory.Quantity)
};
inventory.Quantity -= CurrentDemand + CarryOverShortage;
return(Case);
}
void CreateSimCaseListItem(SimulationCase simCase)
{
var simPanelItem = new SimCaseListItem();
simPanelItem.SimCasePanel.SetValues(simCase);
simPanelItem.OnCopy += new SimCaseEventHandler(simPanelItem_OnCopy);
simPanelItem.OnDelete += new EventHandler(simPanelItem_OnDelete);
flpSimulations.Controls.Add(simPanelItem);
}
public void SetValues(SimulationCase simCase)
{
this.simCase = simCase;
lblSimName.Text = simCase.Name;
lblTalents.Text = simCase.TalentsStr;
lblSymbols.Text = simCase.SymbolsStr;
SetColor();
}
/// <summary>
/// Calculates the values of a single simulation case
/// </summary>
/// <param name="Case">The case that needs to be filled</param>
/// <param name="system">The entire simulation system</param>
/// <param name="rnd">The random number generator, uses the internal random generator if null</param>
static public void SimulationMain(SimulationCase Case, SimulationSystem system, Random rnd = null)
{
if (rnd == null)
{
rnd = Simulator.rnd;
}
Case.RandomNewsDayType = rnd.Next(1, 100);
Case.RandomDemand = rnd.Next(1, 100);
Case.NewsDayType = CalculateDistribution(system.DayTypeDistributions, Case.RandomNewsDayType);
Case.Demand = CalculateDistribution(system.DemandDistributions, Case.NewsDayType, Case.RandomDemand);
ReEvaluateProfit(Case, system);
}
/// <summary>
/// Runs the simulation sequentially
/// </summary>
/// <param name="system">The system to be simulated</param>
static public void SequntialRun(SimulationSystem system, Random rnd = null)
{
for (int i = 0; i < system.NumOfRecords; i++)
{
SimulationCase c = new SimulationCase()
{
DayNo = i + 1
};
Simulator.SimulationMain(c, system, rnd);
system.SimulationTable.Add(c);
}
}
public SimulationCaseOutput(SimulationCase simulationCase)
{
this.CustomerNumber = simulationCase.CustomerNumber;
this.RandomInterArrival = simulationCase.RandomInterArrival;
this.InterArrival = simulationCase.InterArrival;
this.ArrivalTime = simulationCase.ArrivalTime;
this.RandomService = simulationCase.RandomService;
this.ServerID = simulationCase.AssignedServer.ID;
this.StartTime = simulationCase.StartTime;
this.ServiceTime = simulationCase.ServiceTime;
this.EndTime = simulationCase.EndTime;
this.TimeInQueue = simulationCase.TimeInQueue;
}
/// <summary>
/// That seemed important
/// </summary>
static private void CheckFullCycle(SimulationSystem system, SimulationCase Case, Inventory inventory)
{
if (Case.DayWithinCycle == system.ReviewPeriod)
{
Case.OrderQuantity = Math.Max(0, system.OrderUpTo - inventory.Quantity);
Case.RandomLeadDays = rnd.Next(1, 100);
Case.LeadDays = CalculateRandomValue(system.LeadDaysDistribution, Case.RandomLeadDays);
inventory.CurrentOrder = new Order()
{
Quantity = Case.OrderQuantity,
DueDate = Case.LeadDays + Case.Day
};
}
}
private void SimulationTable_Load(object sender, EventArgs e)
{
SimulationCase sc = new SimulationCase();
sc.DailyCost = Program.system.PerformanceMeasures.TotalCost;
sc.SalesProfit = Program.system.PerformanceMeasures.TotalSalesProfit;
sc.LostProfit = Program.system.PerformanceMeasures.TotalLostProfit;
sc.ScrapProfit = Program.system.PerformanceMeasures.TotalScrapProfit;
sc.DailyNetProfit = Program.system.PerformanceMeasures.TotalNetProfit;
Program.system.SimulationTable.Add(sc);
dgv_simulationTable.DataSource = Program.system.SimulationTable;
lbl_excessDemandNum.Text = Program.system.PerformanceMeasures.DaysWithMoreDemand.ToString();
lbl_unsoldPapersNum.Text = Program.system.PerformanceMeasures.DaysWithUnsoldPapers.ToString();
}
public void SetValues(SimulationCase simCase)
{
tbSimName.Text = simCase.Name;
tbIterations.Value = simCase.IterationCount;
tbMaxHp.Value = simCase.TargetMaxHp;
tbMight.Value = simCase.SourceStats.Might;
tbStam.Value = simCase.SourceStats.Stamina;
tbStr.Value = simCase.SourceStats.Str;
tbBrave.Value = simCase.SourceStats.Brave;
tbLuck.Value = simCase.SourceStats.Luck;
tbSpirit.Value = simCase.SourceStats.Spirit;
rtbSymbols.Text = simCase.SymbolsStr;
rtbTalents.Text = simCase.TalentsStr;
}
SimulationCase GetValues()
{
var res = new SimulationCase();
res.Name = tbSimName.Text;
res.IterationCount = Convert.ToInt32(tbIterations.Value);
res.TargetMaxHp = Convert.ToInt32(tbMaxHp.Value);
res.SourceStats.Might = Convert.ToInt32(tbMight.Value);
res.SourceStats.Stamina = Convert.ToInt32(tbStam.Value);
res.SourceStats.Str = Convert.ToInt32(tbStr.Value);
res.SourceStats.Brave = Convert.ToInt32(tbBrave.Value);
res.SourceStats.Luck = Convert.ToInt32(tbLuck.Value);
res.SourceStats.Spirit = Convert.ToInt32(tbSpirit.Value);
res.SymbolsStr = rtbSymbols.Text;
res.TalentsStr = rtbTalents.Text;
return res;
}
/// <summary>
/// Worker thread function
/// </summary>
private void ParallelRunHelper(object num)
{
int i = (int)num;
while (i < CurrentSystem.NumOfRecords)
{
if (RunningMode == Enums.RunningMode.FullRun)
{
SimulationCase c = new SimulationCase()
{
DayNo = i + 1
};
Simulator.SimulationMain(c, CurrentSystem, rnd);
WorkList[i] = c;
}
else
{
Simulator.ReEvaluateProfit(CurrentSystem.SimulationTable[i], CurrentSystem);
}
i += Environment.ProcessorCount;
}
}
/// <summary>
/// A very discriptive name
/// </summary>
static public void StartSimulation(SimulationSystem system)
{
Inventory inventory = new Inventory()
{
Quantity = system.StartInventoryQuantity,
CurrentOrder = new Order()
{
Quantity = system.StartOrderQuantity,
DueDate = system.StartLeadDays
}
};
system.SimulationTable.Clear();
for (int i = 0; i < system.NumberOfDays; i++)
{
SimulationCase Case = GenerateCase(system, inventory, i);
CheckFullCycle(system, Case, inventory);
system.SimulationTable.Add(Case);
system.PerformanceMeasures.EndingInventoryAverage += Case.EndingInventory;
system.PerformanceMeasures.ShortageQuantityAverage += Case.ShortageQuantity;
}
system.PerformanceMeasures.EndingInventoryAverage /= system.NumberOfDays;
system.PerformanceMeasures.ShortageQuantityAverage /= system.NumberOfDays;
}
/// <summary>
/// Re-evaluates the profit of the given case using the pre-calculated demand value
/// </summary>
/// <param name="Case">The simulation case to be re-evaluated</param>
/// <param name="system">The entire simulation system</param>
static public void ReEvaluateProfit(SimulationCase Case, SimulationSystem system)
{
Case.SalesProfit = Math.Min(system.NumOfNewspapers, Case.Demand) * system.SellingPrice;
Case.LostProfit = Math.Max(0, Case.Demand - system.NumOfNewspapers) * (system.SellingPrice - system.PurchasePrice);
Case.ScrapProfit = Math.Max(0, system.NumOfNewspapers - Case.Demand) * system.ScrapPrice;
Case.DailyCost = system.NumOfNewspapers * system.PurchasePrice;
Case.DailyNetProfit = Case.SalesProfit - Case.DailyCost - Case.LostProfit + Case.ScrapProfit;
lock (system)
{
system.PerformanceMeasures.TotalSalesProfit += Case.SalesProfit;
system.PerformanceMeasures.TotalLostProfit += Case.LostProfit;
system.PerformanceMeasures.TotalScrapProfit += Case.ScrapProfit;
system.PerformanceMeasures.TotalCost += Case.DailyCost;
system.PerformanceMeasures.TotalNetProfit += Case.DailyNetProfit;
if (Case.Demand > system.NumOfNewspapers)
{
system.PerformanceMeasures.DaysWithMoreDemand++;
}
if (Case.Demand < system.NumOfNewspapers)
{
system.PerformanceMeasures.DaysWithUnsoldPapers++;
}
}
}
public void running()
{
SimulationCase TempCase0 = new SimulationCase();
TempCase0.CustomerNumber = 1;
TempCase0.ArrivalTime = 0;
TempCase0.InterArrival = -1;
Random rmd = new Random();
TempCase0.RandomService = rmd.Next(1, 100);
TempCase0.RandomInterArrival = rmd.Next(1, 100);
int assignedServerID = -1;
if (sys.SelectionMethod == Enums.SelectionMethod.HighestPriority)
{
assignedServerID = get_hieghst_periority_id(TempCase0.ArrivalTime);
}
else if (sys.SelectionMethod == Enums.SelectionMethod.Random)
{
assignedServerID = get_Random_server_id(TempCase0.ArrivalTime);
}
else if (sys.SelectionMethod == Enums.SelectionMethod.LeastUtilization)
{
assignedServerID = get_least_utilize_id(TempCase0.ArrivalTime);
}
// TempCase0.AssignedServer.ID = assignedServerID;
TempCase0.ServiceTime = get_service_time(assignedServerID, TempCase0.RandomService);
int service_index = get_service_index(assignedServerID);
int finishTime = sys.Servers[service_index].FinishTime;
TempCase0.StartTime = Math.Max(finishTime, TempCase0.ArrivalTime);
TempCase0.EndTime = TempCase0.StartTime + TempCase0.ServiceTime;
TempCase0.TimeInQueue = TempCase0.StartTime - TempCase0.ArrivalTime;
sys.Servers[service_index].number_of_served_customer++;
sys.Servers[service_index].FinishTime = TempCase0.EndTime;
sys.Servers[service_index].TotalWorkingTime += TempCase0.ServiceTime;
Server Temp_ser0 = new Server();
//Temp_ser0.ID = sys.Servers[service_index].ID;
//Temp_ser0.FinishTime = sys.Servers[service_index].FinishTime;
//Temp_ser0.AverageServiceTime = sys.Servers[service_index].AverageServiceTime;
//Temp_ser0.IdleProbability = sys.Servers[service_index].IdleProbability;
//Temp_ser0.number_of_served_customer = sys.Servers[service_index].number_of_served_customer;
//Temp_ser0.TotalWorkingTime = sys.Servers[service_index].TotalWorkingTime;
//Temp_ser0.Utilization = sys.Servers[service_index].Utilization;
//Temp_ser0.TimeDistribution = sys.Servers[service_index].TimeDistribution;
Temp_ser0 = sys.Servers[service_index];
TempCase0.AssignedServer = Temp_ser0;
sys.SimulationTable.Add(TempCase0);
decimal curr_End_Time = TempCase0.EndTime;
Update_Servers_Utilization(curr_End_Time);
// GUI--------------------------------------------------------------------------------------------------------------------
/* string[] row = { sys.SimulationTable[0].CustomerNumber.ToString() , sys.SimulationTable[0].RandomInterArrival.ToString() ,
* sys.SimulationTable[0].InterArrival.ToString(),sys.SimulationTable[0].ArrivalTime.ToString(),
* sys.SimulationTable[0].RandomService.ToString(),sys.SimulationTable[0].StartTime.ToString(),
* sys.SimulationTable[0].ServiceTime.ToString(),sys.SimulationTable[0].EndTime.ToString(),
* sys.SimulationTable[0].TimeInQueue.ToString(),sys.SimulationTable[0].AssignedServer.ID.ToString(),
* sys.Servers[service_index].Utilization.ToString()};
* dataGridView1.Rows.Add(row);*/
// GUI--------------------------------------------------------------------------------------------------------------------
decimal customer_wait_count = 0;
decimal wait_time_customer_summation = 0;
int i = 1;
while (true)
{
SimulationCase TempCase = new SimulationCase();
if (sys.StoppingCriteria == Enums.StoppingCriteria.NumberOfCustomers && sys.StoppingNumber < i + 1)
{
break;
}
TempCase.CustomerNumber = i + 1;
TempCase.RandomInterArrival = rmd.Next(1, 100);
TempCase.RandomService = rmd.Next(1, 100);
TempCase.InterArrival = get_interArrival(TempCase.RandomInterArrival);
TempCase.ArrivalTime = sys.SimulationTable[i - 1].ArrivalTime + TempCase.InterArrival;
if (sys.SelectionMethod == Enums.SelectionMethod.HighestPriority)
{
assignedServerID = get_hieghst_periority_id(TempCase.ArrivalTime);
}
else if (sys.SelectionMethod == Enums.SelectionMethod.Random)
{
assignedServerID = get_Random_server_id(TempCase.ArrivalTime);
}
else if (sys.SelectionMethod == Enums.SelectionMethod.LeastUtilization)
{
assignedServerID = get_least_utilize_id(TempCase.ArrivalTime);
}
TempCase.AssignedServer.ID = assignedServerID;
TempCase.ServiceTime = get_service_time(assignedServerID, TempCase.RandomService);
service_index = get_service_index(assignedServerID);
finishTime = sys.Servers[service_index].FinishTime;
TempCase.StartTime = Math.Max(finishTime, TempCase.ArrivalTime);
TempCase.EndTime = TempCase.StartTime + TempCase.ServiceTime;
TempCase.TimeInQueue = TempCase.StartTime - TempCase.ArrivalTime;
if (sys.StoppingCriteria == Enums.StoppingCriteria.SimulationEndTime && TempCase.EndTime > sys.StoppingNumber)
{
break;
}
if (TempCase.TimeInQueue > 0)
{
customer_wait_count++;
}
wait_time_customer_summation += TempCase.TimeInQueue;
sys.Servers[service_index].TotalWorkingTime += TempCase.ServiceTime;
sys.Servers[service_index].number_of_served_customer++;
sys.Servers[service_index].FinishTime = TempCase.EndTime;
Server Temp_ser = new Server();
//Temp_ser.ID = sys.Servers[service_index].ID;
//Temp_ser.FinishTime = sys.Servers[service_index].FinishTime;
//Temp_ser.AverageServiceTime = sys.Servers[service_index].AverageServiceTime;
//Temp_ser.IdleProbability = sys.Servers[service_index].IdleProbability;
//Temp_ser.number_of_served_customer = sys.Servers[service_index].number_of_served_customer;
//Temp_ser.TotalWorkingTime = sys.Servers[service_index].TotalWorkingTime;
//Temp_ser.Utilization = sys.Servers[service_index].Utilization;
//Temp_ser.TimeDistribution = sys.Servers[service_index].TimeDistribution;
Temp_ser = sys.Servers[service_index];
TempCase.AssignedServer = Temp_ser;
sys.SimulationTable.Add(TempCase);
curr_End_Time = Math.Max(curr_End_Time, TempCase.EndTime);
Update_Servers_Utilization(curr_End_Time);
// GUI----------------------------------------------------------------------------------------------------------------------
/*string[] row1 = { sys.SimulationTable[i].CustomerNumber.ToString() , sys.SimulationTable[i].RandomInterArrival.ToString() ,
* sys.SimulationTable[i].InterArrival.ToString(),sys.SimulationTable[i].ArrivalTime.ToString(),
* sys.SimulationTable[i].RandomService.ToString(),sys.SimulationTable[i].StartTime.ToString(),
* sys.SimulationTable[i].ServiceTime.ToString(),sys.SimulationTable[i].EndTime.ToString(),
* sys.SimulationTable[i].TimeInQueue.ToString(),sys.SimulationTable[i].AssignedServer.ID.ToString(),
* sys.Servers[service_index].Utilization.ToString()};
* dataGridView1.Rows.Add(row1);*/
// GUI----------------------------------------------------------------------------------------------------------------------
i++;
}
int max_queue_length = -1, cnt = 1;
bool inqeue = false;
for (int j = 0; j < sys.SimulationTable.Count; j++)
{
int k = j + 1;
while (k < sys.SimulationTable.Count && sys.SimulationTable[k].ArrivalTime < sys.SimulationTable[j].StartTime)
{
inqeue = true;
cnt++;
k++;
}
max_queue_length = Math.Max(max_queue_length, cnt);
cnt = 1;
}
//sys.StoppingNumbe
sys.PerformanceMeasures.AverageWaitingTime = (decimal)(wait_time_customer_summation / i);
sys.PerformanceMeasures.WaitingProbability = (decimal)(customer_wait_count / i);
if (inqeue)
{
sys.PerformanceMeasures.MaxQueueLength = max_queue_length;
}
else
{
sys.PerformanceMeasures.MaxQueueLength = 0;
}
//dinamic
decimal end_of_sim_time = -1;
for (int j = 0; j < sys.Servers.Count; j++)
{
end_of_sim_time = Math.Max(sys.Servers[j].FinishTime, end_of_sim_time);
}
for (int j = 0; j < sys.Servers.Count; j++)
{
decimal idl = /*end_of_sim_time*/ curr_End_Time - sys.Servers[j].TotalWorkingTime;
sys.Servers[j].IdleProbability = (idl / curr_End_Time /*end_of_sim_time*/);
if (sys.Servers[j].number_of_served_customer == 0)
{
sys.Servers[j].AverageServiceTime = 0;
}
else
{
sys.Servers[j].AverageServiceTime = (decimal)(sys.Servers[j].TotalWorkingTime / sys.Servers[j].number_of_served_customer);
}
sys.Servers[j].Utilization = (decimal)(sys.Servers[j].TotalWorkingTime / curr_End_Time /*end_of_sim_time*/);
}
}
void start()
{
int cid = 0;
per.AverageWaitingTime = 0;
per.WaitingProbability = 0;
per.MaxQueueLength = 0;
int queue = 0;
List <int> queu = new List <int>();
Random rnd = new Random();
Random rnd2 = new Random();
while (true)
{
cid++;
if (sys.StoppingCriteria == Enums.StoppingCriteria.NumberOfCustomers)
{
if (stop(cid))
{
break;
}
}
SimulationCase cas = new SimulationCase(cid);
cas.RandomInterArrival = rnd.Next(1, 101);
cas.InterArrival = get1(cas.RandomInterArrival);
if (cid == 1)
{
cas.ArrivalTime = 0;
}
else
{
cas.ArrivalTime = cas.InterArrival + sys.SimulationTable[cid - 2].ArrivalTime;
}
if (sys.StoppingCriteria == Enums.StoppingCriteria.SimulationEndTime)
{
if (stop(cas.ArrivalTime))
{
break;
}
}
cas.RandomService = rnd2.Next(1, 101);
cas.TimeInQueue = -1;
if (sys.SelectionMethod == Enums.SelectionMethod.HighestPriority)
{
for (int i = 0; i < sys.NumberOfServers; i++)
{
if (sys.Servers[i].FinishTime <= cas.ArrivalTime)
{
sys.Servers[i].idle += Math.Abs(cas.ArrivalTime - sys.Servers[i].FinishTime);
cas.ServiceTime = get2(cas.RandomService, sys.Servers[i]);
cas.TimeInQueue = 0;
sys.Servers[i].FinishTime = cas.ArrivalTime + cas.ServiceTime;
cas.StartTime = cas.ArrivalTime;
cas.EndTime = cas.ArrivalTime + cas.ServiceTime;
cas.AssignedServer = sys.Servers[i];
sys.Servers[i].TotalWorkingTime += cas.ServiceTime;
sys.Servers[i].customers++;
queue = 0;
cas.idd = sys.Servers[i].ID;
break;
}
}
if (cas.TimeInQueue == -1)
{
for (int i = 0; i < queu.Count; i++)
{
if (cas.ArrivalTime >= queu[i])
{
queu.RemoveAt(i);
}
}
int mn = 1000000000, ind = 0;
queue++;
for (int i = 0; i < sys.NumberOfServers; i++)
{
if (sys.Servers[i].FinishTime < mn)
{
mn = sys.Servers[i].FinishTime;
ind = i;
}
}
queu.Add(mn);
cas.ServiceTime = get2(cas.RandomService, sys.Servers[ind]);
cas.TimeInQueue = sys.Servers[ind].FinishTime - cas.ArrivalTime;
sys.Servers[ind].FinishTime = mn + cas.ServiceTime;
cas.StartTime = mn;
cas.EndTime = mn + cas.ServiceTime;
cas.AssignedServer = sys.Servers[ind];
per.AverageWaitingTime += cas.TimeInQueue;
per.WaitingProbability++;
sys.Servers[ind].TotalWorkingTime += cas.ServiceTime;
sys.Servers[ind].customers++;
cas.idd = sys.Servers[ind].ID;
}
per.MaxQueueLength = Math.Max(per.MaxQueueLength, queu.Count);
}
else if (sys.SelectionMethod == Enums.SelectionMethod.LeastUtilization)
{
List <Server> sers = new System.Collections.Generic.List <Server>();
decimal mn = 10000000;
int mnn = 10000000;
foreach (Server ser in sys.Servers)
{
ser.Utilization = (decimal)(ser.TotalWorkingTime);
if (ser.FinishTime <= cas.ArrivalTime)
{
mn = Math.Min(mn, ser.Utilization);
sers.Add(ser);
}
mnn = Math.Min(mnn, ser.FinishTime);
}
if (sers.Count > 0)
{
int ind = 0;
foreach (Server ser in sers)
{
if (ser.Utilization == mn)
{
ind = ser.ID - 1;
break;
}
}
sys.Servers[ind].idle += Math.Abs(cas.ArrivalTime - sys.Servers[ind].FinishTime);
cas.ServiceTime = get2(cas.RandomService, sys.Servers[ind]);
cas.TimeInQueue = 0;
sys.Servers[ind].FinishTime = cas.ArrivalTime + cas.ServiceTime;
cas.StartTime = cas.ArrivalTime;
cas.EndTime = cas.ArrivalTime + cas.ServiceTime;
cas.AssignedServer = sys.Servers[ind];
sys.Servers[ind].TotalWorkingTime += cas.ServiceTime;
sys.Servers[ind].customers++;
cas.idd = sys.Servers[ind].ID;
queue = 0;
}
else
{
sers = new System.Collections.Generic.List <Server>();
mn = 10000000;
foreach (Server ser in sys.Servers)
{
if (ser.FinishTime == mnn)
{
mn = Math.Min(mn, ser.Utilization);
sers.Add(ser);
}
}
int ind = 0;
foreach (Server ser in sers)
{
if (ser.Utilization == mn)
{
ind = ser.ID - 1;
break;
}
}
for (int i = 0; i < queu.Count; i++)
{
if (cas.ArrivalTime >= queu[i])
{
queu.RemoveAt(i);
}
}
queu.Add(mnn);
cas.ServiceTime = get2(cas.RandomService, sys.Servers[ind]);
cas.TimeInQueue = sys.Servers[ind].FinishTime - cas.ArrivalTime;
sys.Servers[ind].FinishTime = mnn + cas.ServiceTime;
cas.StartTime = mnn;
cas.EndTime = mnn + cas.ServiceTime;
cas.AssignedServer = sys.Servers[ind];
per.AverageWaitingTime += cas.TimeInQueue;
per.WaitingProbability++;
sys.Servers[ind].TotalWorkingTime += cas.ServiceTime;
sys.Servers[ind].customers++;
cas.idd = sys.Servers[ind].ID;
}
per.MaxQueueLength = Math.Max(per.MaxQueueLength, queu.Count);
}
else
{
Random rnd1 = new Random();
List <Server> sers = new System.Collections.Generic.List <Server>();
decimal mn = 10000000;
int mnn = 10000000;
foreach (Server ser in sys.Servers)
{
if (ser.FinishTime <= cas.ArrivalTime)
{
sers.Add(ser);
}
mnn = Math.Min(mnn, ser.FinishTime);
}
if (sers.Count > 0)
{
int ind = rnd1.Next(0, sers.Count);
ind = sers[ind].ID - 1;
sys.Servers[ind].idle += Math.Abs(cas.ArrivalTime - sys.Servers[ind].FinishTime);
cas.ServiceTime = get2(cas.RandomService, sys.Servers[ind]);
cas.TimeInQueue = 0;
sys.Servers[ind].FinishTime = cas.ArrivalTime + cas.ServiceTime;
cas.StartTime = cas.ArrivalTime;
cas.EndTime = cas.ArrivalTime + cas.ServiceTime;
cas.AssignedServer = sys.Servers[ind];
sys.Servers[ind].TotalWorkingTime += cas.ServiceTime;
sys.Servers[ind].customers++;
cas.idd = sys.Servers[ind].ID;
}
else
{
sers = new System.Collections.Generic.List <Server>();
foreach (Server ser in sys.Servers)
{
if (ser.FinishTime == mnn)
{
sers.Add(ser);
}
}
int ind = rnd1.Next(0, sers.Count);
ind = sers[ind].ID - 1;
for (int i = 0; i < queu.Count; i++)
{
if (cas.ArrivalTime >= queu[i])
{
queu.RemoveAt(i);
}
}
queu.Add(mnn);
cas.ServiceTime = get2(cas.RandomService, sys.Servers[ind]);
cas.TimeInQueue = sys.Servers[ind].FinishTime - cas.ArrivalTime;
sys.Servers[ind].FinishTime = mnn + cas.ServiceTime;
cas.StartTime = mnn;
cas.EndTime = mnn + cas.ServiceTime;
cas.AssignedServer = sys.Servers[ind];
per.AverageWaitingTime += cas.TimeInQueue;
per.WaitingProbability++;
sys.Servers[ind].TotalWorkingTime += cas.ServiceTime;
sys.Servers[ind].customers++;
cas.idd = sys.Servers[ind].ID;
}
per.MaxQueueLength = Math.Max(per.MaxQueueLength, queu.Count);
}
for (int t = cas.StartTime; cas.StartTime <= 20 && t <= cas.EndTime; t++)
{
sys.Servers[cas.AssignedServer.ID - 1].x.Add(t);
sys.Servers[cas.AssignedServer.ID - 1].y.Add(1);
}
sys.SimulationTable.Add(cas);
total_run = Math.Max(total_run, cas.EndTime);
}
per.WaitingProbability = per.WaitingProbability / (sys.SimulationTable.Count);
per.AverageWaitingTime = per.AverageWaitingTime / (sys.SimulationTable.Count);
sys.PerformanceMeasures = per;
get_per();
}
private void button3_Click(object sender, EventArgs e)
{
dataGridView2.Rows.Clear();
dataGridView2.Columns.Clear();
SimulationCase temp = new SimulationCase();
Random r = new Random();
dataGridView2.Columns.Add("Day", "Day");
dataGridView2.Columns.Add("RandomTypeNewsDay", "RandomTypeNewsDay");
dataGridView2.Columns.Add("TypeOfNewsDay", "TypeOfNewsDay");
dataGridView2.Columns.Add("RandomDemand", "RandomDemand");
dataGridView2.Columns.Add("Demand", "Demand");
dataGridView2.Columns.Add("DailyCost", "DailyCost");
dataGridView2.Columns.Add("RevenueFromSale", "RevenueFromSale");
dataGridView2.Columns.Add("LostProfit", "LostProfit");
dataGridView2.Columns.Add("SaleAsScrap", "SaleAsScrap");
dataGridView2.Columns.Add("DailyProfit", "DailyProfit");
for (int i = 0; i < mySystem.NumOfRecords; i++)
{
temp = new SimulationCase();
temp.DayNo = i + 1;
int k = 0;
temp.RandomNewsDayType = r.Next(1, 100);
for (int j = 0; j < mySystem.DayTypeDistributions.Count; j++)
{
if ((temp.RandomNewsDayType <= mySystem.DayTypeDistributions[j].MaxRange || mySystem.DayTypeDistributions[j].MaxRange == 0) &&
temp.RandomNewsDayType >= mySystem.DayTypeDistributions[j].MinRange)
{
temp.NewsDayType = mySystem.DayTypeDistributions[j].DayType;
k = j;
break;
}
}
temp.RandomDemand = r.Next(1, 100);
for (int j = 0; j < mySystem.DemandDistributions.Count; j++)
{
//MessageBox.Show(mySystem.DemandDistributions[j].DayTypeDistributions[k].MaxRange.ToString());
if ((mySystem.DemandDistributions[j].DayTypeDistributions[k].MaxRange >= temp.RandomDemand || mySystem.DemandDistributions[j].DayTypeDistributions[k].MaxRange == 0) &&
mySystem.DemandDistributions[j].DayTypeDistributions[k].MinRange <= temp.RandomDemand)
{
temp.Demand = mySystem.DemandDistributions[j].Demand;
break;
}
}
temp.SalesProfit = temp.Demand * (mySystem.PurchasePrice);
if (temp.Demand > mySystem.NumOfNewspapers)
{
temp.SalesProfit = mySystem.NumOfNewspapers * (mySystem.PurchasePrice / mySystem.UnitProfit);
temp.LostProfit = ((temp.Demand - mySystem.NumOfNewspapers) * ((mySystem.PurchasePrice - mySystem.SellingPrice) / mySystem.UnitProfit));
temp.ScrapProfit = 0;
}
else
{
temp.SalesProfit = temp.Demand * (mySystem.PurchasePrice / mySystem.UnitProfit);
temp.LostProfit = 0;
temp.ScrapProfit = (mySystem.ScrapPrice / mySystem.UnitProfit) * (mySystem.NumOfNewspapers - temp.Demand);
}
temp.DailyCost = ((double)(mySystem.NumOfNewspapers) * mySystem.SellingPrice) / mySystem.UnitProfit;
temp.DailyNetProfit = temp.SalesProfit - temp.DailyCost - temp.LostProfit + temp.ScrapProfit;
mySystem.SimulationCases.Add(temp);
dataGridView2.Rows.Add(temp.DayNo, temp.RandomNewsDayType, temp.NewsDayType, temp.RandomDemand, temp.Demand, temp.DailyCost, temp.SalesProfit, temp.LostProfit, temp.ScrapProfit, temp.DailyNetProfit);
mySystem.PerformanceMeasures.TotalCost += temp.DailyCost;
mySystem.PerformanceMeasures.TotalLostProfit += temp.LostProfit;
mySystem.PerformanceMeasures.TotalSalesProfit += temp.SalesProfit;
mySystem.PerformanceMeasures.TotalScrapProfit += temp.ScrapProfit;
mySystem.PerformanceMeasures.TotalNetProfit += Math.Round(temp.DailyNetProfit, 1);
if (temp.LostProfit != 0)
{
mySystem.PerformanceMeasures.DaysWithMoreDemand++;
}
else if (temp.ScrapProfit != 0)
{
mySystem.PerformanceMeasures.DaysWithUnsoldPapers++;
}
}
textBox1.Text = mySystem.PerformanceMeasures.DaysWithUnsoldPapers.ToString();
textBox2.Text = mySystem.PerformanceMeasures.TotalScrapProfit.ToString();
textBox3.Text = mySystem.PerformanceMeasures.TotalLostProfit.ToString();
textBox4.Text = mySystem.PerformanceMeasures.TotalNetProfit.ToString();
textBox5.Text = mySystem.PerformanceMeasures.DaysWithMoreDemand.ToString();
textBox7.Text = mySystem.PerformanceMeasures.TotalCost.ToString();
textBox8.Text = mySystem.PerformanceMeasures.TotalSalesProfit.ToString();
string s = TestingManager.Test(mySystem, Constants.FileNames.TestCase1);
MessageBox.Show(s);
}
public SimCaseEventArgs(SimulationCase simCase)
: base()
{
SimCase = simCase;
}
private void button1_Click(object sender, EventArgs e)
{
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
try
{
string[] lines = File.ReadAllLines(openFileDialog1.FileName);
simulationSystem.NumberOfServers = Convert.ToInt32(lines[1]);
for (int i = 0; i < simulationSystem.NumberOfServers; i++)
{
simulationSystem.Servers.Add(new Server());
simulationSystem.Servers[i].ID = i + 1;
simulationSystem.Servers[i].FinishTime = -1;
simulationSystem.Servers[i].TotalWorkingTime = 0;
freqServers.Add(0);
}
simulationSystem.StoppingNumber = Convert.ToInt32(lines[4]);
simulationSystem.StoppingCriteria = (Enums.StoppingCriteria)Convert.ToInt32(lines[7]);
simulationSystem.SelectionMethod = (Enums.SelectionMethod)Convert.ToInt32(lines[10]);
int currentLine = 13;
decimal cumulative = 0;
while (lines[currentLine] != "")
{
string[] separator = { ", " };
string[] values = lines[currentLine].Split(separator, 2, StringSplitOptions.RemoveEmptyEntries);
TimeDistribution td = new TimeDistribution();
td.Time = Convert.ToInt32(values[0]);
td.Probability = Convert.ToDecimal(values[1]);
td.MinRange = (int)(cumulative * 100 + 1);
cumulative += td.Probability;
td.MaxRange = (int)(cumulative * 100);
td.CummProbability = cumulative;
simulationSystem.InterarrivalDistribution.Add(td);
currentLine++;
}
for (int i = 0; i < simulationSystem.NumberOfServers; i++)
{
currentLine += 2;
cumulative = 0;
while (currentLine < lines.Length && lines[currentLine] != "")
{
string[] separator = { ", " };
string[] values = lines[currentLine].Split(separator, 2, StringSplitOptions.RemoveEmptyEntries);
TimeDistribution td = new TimeDistribution();
td.Time = Convert.ToInt32(values[0]);
td.Probability = Convert.ToDecimal(values[1]);
td.MinRange = (int)(cumulative * 100 + 1);
cumulative += td.Probability;
td.MaxRange = (int)(cumulative * 100);
td.CummProbability = cumulative;
simulationSystem.Servers[i].TimeDistribution.Add(td);
currentLine++;
}
}
Random rnd = new Random();
int tc = 0;
while ((tc < simulationSystem.StoppingNumber && (int)simulationSystem.StoppingCriteria == 1) || (simulationFinishTime <= simulationSystem.StoppingNumber && (int)simulationSystem.StoppingCriteria == 2))
{
tc++;
SimulationCase simulationCase = new SimulationCase();
simulationCase.CustomerNumber = tc;
if (tc == 1)
{
simulationCase.ArrivalTime = 0;
simulationCase.RandomService = rnd.Next(1, 100);
simulationCase.StartTime = 0;
simulationCase.ServiceTime = binarySearch(simulationCase.RandomService, simulationSystem.Servers[0].TimeDistribution);
simulationCase.EndTime = simulationCase.StartTime + simulationCase.ServiceTime;
simulationFinishTime = Math.Max(simulationFinishTime, simulationCase.EndTime);
simulationSystem.Servers[0].FinishTime = simulationCase.EndTime;
simulationSystem.Servers[0].TotalWorkingTime += simulationCase.ServiceTime;
simulationCase.AssignedServer = simulationSystem.Servers[0];
freqServers[0]++;
simulationSystem.SimulationTable.Add(simulationCase);
continue;
}
simulationCase.RandomInterArrival = rnd.Next(1, 100);
simulationCase.InterArrival = binarySearch(simulationCase.RandomInterArrival, simulationSystem.InterarrivalDistribution);
simulationCase.ArrivalTime = simulationCase.InterArrival + simulationSystem.SimulationTable[tc - 2].ArrivalTime;
Tuple <int, int> bestServer = selectServer(simulationCase.ArrivalTime);
freqServers[bestServer.Item2]++;
simulationCase.AssignedServer = simulationSystem.Servers[bestServer.Item2];
simulationCase.RandomService = rnd.Next(1, 100);
simulationCase.ServiceTime = binarySearch(simulationCase.RandomService, simulationSystem.Servers[bestServer.Item2].TimeDistribution);
simulationCase.StartTime = Math.Max(simulationCase.ArrivalTime, bestServer.Item1);
simulationCase.EndTime = simulationCase.StartTime + simulationCase.ServiceTime;
simulationFinishTime = Math.Max(simulationFinishTime, simulationCase.EndTime);
simulationCase.TimeInQueue = simulationCase.StartTime - simulationCase.ArrivalTime;
if (simulationCase.TimeInQueue > 0)
{
simulationSystem.PerformanceMeasures.WaitingProbability++;
}
for (int i = simulationCase.ArrivalTime; i < simulationCase.StartTime; i++)
{
queueFreq[i]++;
simulationSystem.PerformanceMeasures.MaxQueueLength = Math.Max(simulationSystem.PerformanceMeasures.MaxQueueLength, queueFreq[i]);
}
simulationSystem.PerformanceMeasures.MaxQueueLength = Math.Max(simulationSystem.PerformanceMeasures.MaxQueueLength, currentQueueLength);
simulationSystem.PerformanceMeasures.AverageWaitingTime += simulationCase.TimeInQueue;
simulationSystem.Servers[bestServer.Item2].FinishTime = simulationCase.EndTime;
simulationSystem.Servers[bestServer.Item2].TotalWorkingTime += simulationCase.ServiceTime;
simulationSystem.SimulationTable.Add(simulationCase);
}
for (int i = 0; i < simulationSystem.NumberOfServers; i++)
{
simulationSystem.Servers[i].IdleProbability = (simulationFinishTime - simulationSystem.Servers[i].TotalWorkingTime) / (decimal)simulationFinishTime;
simulationSystem.Servers[i].AverageServiceTime = simulationSystem.Servers[i].TotalWorkingTime / (decimal)freqServers[i];
simulationSystem.Servers[i].Utilization = simulationSystem.Servers[i].TotalWorkingTime / (decimal)simulationFinishTime;
}
simulationSystem.PerformanceMeasures.AverageWaitingTime /= simulationSystem.StoppingNumber;
simulationSystem.PerformanceMeasures.WaitingProbability /= simulationSystem.StoppingNumber;
waitingLabel.Text = simulationSystem.PerformanceMeasures.AverageWaitingTime.ToString();
probabilityLabel.Text = simulationSystem.PerformanceMeasures.WaitingProbability.ToString();
queueLabel.Text = simulationSystem.PerformanceMeasures.MaxQueueLength.ToString();
serversOutput.DataSource = simulationSystem.Servers;
outputGrid.DataSource = simulationSystem.SimulationTable;
outputGrid.Columns.Remove("AssignedServer");
outputGrid.Columns.Add("ServerID", "ServerID");
for (int i = 0; i < simulationSystem.StoppingNumber; i++)
{
outputGrid[outputGrid.Columns.Count - 1, i].Value = simulationSystem.SimulationTable[i].AssignedServer.ID;
}
}
catch
{
MessageBox.Show("You have selected a worng file!");
}
simulationSystem.SimulationTable[0].RandomInterArrival = 1;
string testingResult = TestingManager.Test(simulationSystem, Constants.FileNames.TestCase1);
MessageBox.Show(testingResult);
}
}
/// <summary>
/// Entry point of the simulator
/// </summary>
/// <param name="System">The system to be simulated</param>
static private void SimulationMain(SimulationSystem System)
{
Queue <SimulationCase> Queue = new Queue <SimulationCase>();
int SimulationTime = 0;
int Total_TimeinQueue = 0;
int Number_Of_Customers_Who_Waited = 0;
int Max_QueueLength = 0;
List <SimulationCase> Cases = new List <SimulationCase>();
if (System.StoppingCriteria == Enums.StoppingCriteria.NumberOfCustomers)
{
for (int i = 0; i < System.StoppingNumber; i++)
{
SimulationCase c = new SimulationCase
{
CustomerNumber = i,
RandomInterArrival = rnd.Next(1, 100)
};
if (i == 0)
{
c.InterArrival = 0;
c.ArrivalTime = 0;
}
else
{
c.InterArrival = CalculateRandomValue(System.InterarrivalDistribution, c.RandomInterArrival);
c.ArrivalTime = Cases[i - 1].ArrivalTime + c.InterArrival;
}
GetAssignedServer(c, System.Servers, System.SelectionMethod);
SimulationTime = Math.Max(SimulationTime, c.EndTime);
while (Queue.Count > 0)
{
if (Queue.Peek().StartTime <= c.ArrivalTime)
{
Queue.Dequeue();
}
else
{
break;
}
}
if (c.TimeInQueue > 0)
{
Queue.Enqueue(c);
Total_TimeinQueue += c.TimeInQueue;
Number_Of_Customers_Who_Waited++;
}
Max_QueueLength = Math.Max(Max_QueueLength, Queue.Count);
Cases.Add(c);
}
}
else
{
int Counter = 0;
while (true)
{
SimulationCase c = new SimulationCase
{
CustomerNumber = Counter,
RandomInterArrival = rnd.Next(1, 100)
};
if (Cases.Count == 0)
{
c.InterArrival = 0;
c.ArrivalTime = 0;
}
else
{
c.InterArrival = CalculateRandomValue(System.InterarrivalDistribution, c.RandomInterArrival);
c.ArrivalTime = Cases[Cases.Count - 1].ArrivalTime + c.InterArrival;
}
if (c.ArrivalTime > System.StoppingNumber)
{
break;
}
GetAssignedServer(c, System.Servers, System.SelectionMethod);
while (Queue.Count > 0)
{
if (Queue.Peek().StartTime <= c.ArrivalTime)
{
Queue.Dequeue();
}
else
{
break;
}
}
if (c.TimeInQueue > 0)
{
Queue.Enqueue(c);
Total_TimeinQueue += c.TimeInQueue;
Number_Of_Customers_Who_Waited++;
}
SimulationTime = Math.Max(SimulationTime, c.EndTime);
Max_QueueLength = Math.Max(Max_QueueLength, Queue.Count);
Counter++;
Cases.Add(c);
}
}
System.PerformanceMeasures.AverageWaitingTime = ((decimal)Total_TimeinQueue / Cases.Count);
System.PerformanceMeasures.WaitingProbability = ((decimal)Number_Of_Customers_Who_Waited / Cases.Count);
System.PerformanceMeasures.MaxQueueLength = Max_QueueLength;
System.SimulationTable = Cases;
System.TotalSimulationTime = SimulationTime;
for (int i = 0; i < System.Servers.Count; i++)
{
if (System.Servers[i].ServedCount != 0)
{
System.Servers[i].AverageServiceTime /= System.Servers[i].ServedCount;
}
System.Servers[i].Utilization = (decimal)System.Servers[i].TotalWorkingTime / SimulationTime;
}
}
private void StartRandomSimulation()
{
if (App.SimulationSystem.StoppingCriteria == Enums.StoppingCriteria.NumberOfCustomers)
{
for (int i = 0; i < App.SimulationSystem.StoppingNumber; i++)
{
SimulationCase temp = new SimulationCase();
temp.CustomerNumber = i + 1;
if (i == 0)
{
temp.InterArrival = 0;
temp.ArrivalTime = 0;
}
else
{
temp.RandomInterArrival = App.GeneralRandomFunction(1, 100);
temp.InterArrival = GetValueFromDistribution(temp.RandomInterArrival, App.SimulationSystem.InterarrivalDistribution);
temp.ArrivalTime += temp.InterArrival + App.SimulationSystem.SimulationTable[i - 1].ArrivalTime;
}
foreach (var item in App.SimulationSystem.Servers)
{
if (item.FinishTime > temp.ArrivalTime)
{
item.IsAvailable = false;
}
else if (item.FinishTime <= temp.ArrivalTime)
{
item.IsAvailable = true;
}
}
temp.RandomService = App.GeneralRandomFunction(1, 100);
Server AssignedServer = RandomServerSelect(App.SimulationSystem.Servers);
if (AssignedServer == null)
{
int min = App.SimulationSystem.Servers[0].FinishTime;
int ind = 0;
for (int q = 0; q < App.SimulationSystem.Servers.Count; q++)
{
if (App.SimulationSystem.Servers[q].FinishTime < min)
{
min = App.SimulationSystem.Servers[q].FinishTime;
ind = q;
}
}
temp.TimeInQueue = min - temp.ArrivalTime;
temp.AssignedServer = App.SimulationSystem.Servers[ind];
}
else
{
int index = App.SimulationSystem.Servers.IndexOf(AssignedServer);
temp.AssignedServer = App.SimulationSystem.Servers[index];
temp.TimeInQueue = 0;
}
temp.ServiceTime = GetValueFromDistribution(temp.RandomService, temp.AssignedServer.TimeDistribution);
temp.StartTime = temp.ArrivalTime + temp.TimeInQueue;
temp.EndTime = temp.ArrivalTime + temp.ServiceTime;
temp.AssignedServer.FinishTime = temp.EndTime;
App.SimulationSystem.SimulationTable.Add(temp);
}
}
else if (App.SimulationSystem.StoppingCriteria == Enums.StoppingCriteria.SimulationEndTime)
{
}
}
public void FillSimulationTable()
{
Random rand = new Random();
for (int i = 0; i < simSys.NumOfRecords; i++)
{
SimulationCase simRow = new SimulationCase();
simRow.DayNo = i + 1;
simRow.RandomNewsDayType = rand.Next(1, 101);//chech if 101 is included or not
simRow.RandomDemand = rand.Next(1, 101);
/////////////////////Day Type///////////////////////////////
for (int j = 0; j < simSys.DayTypeDistributions.Count(); j++)
{
if (simRow.RandomNewsDayType >= simSys.DayTypeDistributions[j].MinRange && simRow.RandomNewsDayType <= simSys.DayTypeDistributions[j].MaxRange)
{
simRow.NewsDayType = simSys.DayTypeDistributions[j].DayType;
break;
}
}
///////////////////////Demand///////////////////////////////
for (int j = 0; j < simSys.DemandDistributions.Count(); j++)
{
int DaytypeListSize = simSys.DemandDistributions[j].DayTypeDistributions.Count();
for (int k = 0; k < DaytypeListSize; k++)
{
if (simRow.NewsDayType == simSys.DemandDistributions[j].DayTypeDistributions[k].DayType &&
simRow.RandomDemand >= simSys.DemandDistributions[j].DayTypeDistributions[k].MinRange &&
simRow.RandomDemand <= simSys.DemandDistributions[j].DayTypeDistributions[k].MaxRange)
{
simRow.Demand = simSys.DemandDistributions[j].Demand;
break;
}
}
}
////////////////////////Calculations///////////////////////////
///////////////////////Cost///////////////////////////////
simRow.DailyCost = simSys.NumOfNewspapers * simSys.PurchasePrice;
//////////////////////Sales Profit///////////////////////
if (simRow.Demand <= simSys.NumOfNewspapers)
{
simRow.SalesProfit = simRow.Demand * simSys.SellingPrice;
}
else
{
simRow.SalesProfit = simSys.NumOfNewspapers * simSys.SellingPrice;
}
//////////////////////Lost//////////////////////////////
if (simRow.Demand > simSys.NumOfNewspapers)
{
simRow.LostProfit = (simRow.Demand - simSys.NumOfNewspapers) * (simSys.SellingPrice - simSys.PurchasePrice);
}
else
{
simRow.LostProfit = 0;
}
////////////////////////Scrap//////////////////////////////
if (simRow.Demand < simSys.NumOfNewspapers)
{
simRow.ScrapProfit = (simSys.NumOfNewspapers - simRow.Demand) * simSys.ScrapPrice;
}
else
{
simRow.ScrapProfit = 0;
}
////////////////////////////////////////////////////////////
simRow.DailyNetProfit = (simRow.SalesProfit - simRow.DailyCost - simRow.LostProfit + simRow.ScrapProfit);
simSys.SimulationTable.Add(simRow);
}
}
public void start_process()
{
int lastEndTime = 0;
int maxQueueLength = 0;
int totalWaitingTime = 0;
int totalSimulationTime = 0;
int NoOfCustomerWhoWaited = 0;
List <SimulationCase> queue = new List <SimulationCase>();
while ((sys.stoppingCase == "NumberOfCustomers" && customersCount < sys.StoppingNumber) || (sys.stoppingCase == "SimulationEndTime" && lastEndTime < sys.StoppingNumber))
{
// generate a new customer
row = new SimulationCase();
// server assignment
if (customersCount == 0) // 1st customer arrival
{
row.ArrivalTime = 0;
if (sys.selectionMethod == "HighestPriority")
{
row.AssignedServer = sys.Servers[sys.HP];
}
else
{
int random = rand.Next(0, sys.Servers.Count);
row.AssignedServer = sys.Servers[random];
}
row.RandomInterArrival = 1;
}
else // the rest of the customers
{
row.RandomInterArrival = rand.Next(1, 101);
row.InterArrival = get_Range(sys.InterarrivalDistribution, row.RandomInterArrival);
row.ArrivalTime = sys.SimulationTable[customersCount - 1].ArrivalTime + row.InterArrival;
// assign server
if (sys.selectionMethod == "HighestPriority")
{
if (row.ArrivalTime >= sys.Servers[sys.HP].currentEnd)
{
row.AssignedServer = sys.Servers[sys.HP];
}
else
{
// search for another idle server
foreach (var server in sys.Servers)
{
if (row.ArrivalTime >= server.currentEnd)
{
row.AssignedServer = server;
break;
}
}
// in case there is no idle servers
if (row.AssignedServer.ID == 0)
{
// select server with minimum end time
int min = sys.Servers[0].currentEnd;
int server_id = 1;
foreach (var server in sys.Servers)
{
if (server.currentEnd < min)
{
min = server.currentEnd;
server_id = server.ID;
}
}
// pass to the waiting queue
row.AssignedServer = sys.Servers[server_id - 1];
row.TimeInQueue = row.AssignedServer.currentEnd - row.ArrivalTime;
// performance calculations
NoOfCustomerWhoWaited++;
totalWaitingTime += row.TimeInQueue;
}
}
}
else // random server
{
// search for a random idle server
for (int i = sys.Servers.Count - 1; i >= 0; i--)
{
if (row.ArrivalTime >= sys.Servers[i].currentEnd)
{
row.AssignedServer = sys.Servers[i];
break;
}
}
// in case there is no idle servers
if (row.AssignedServer.ID == 0)
{
// select server with minimum end time
int min = sys.Servers[0].currentEnd;
int server_id = 1;
foreach (var server in sys.Servers)
{
if (server.currentEnd < min)
{
min = server.currentEnd;
server_id = server.ID;
}
}
// pass to the waiting queue
row.AssignedServer = sys.Servers[server_id - 1];
row.TimeInQueue = row.AssignedServer.currentEnd - row.ArrivalTime;
// performance calculations
NoOfCustomerWhoWaited++;
totalWaitingTime += row.TimeInQueue;
}
}
}
row.RandomService = rand.Next(1, 101);
row.ServiceTime = get_Range(row.AssignedServer.TimeDistribution, row.RandomService);
row.StartTime = row.ArrivalTime + row.TimeInQueue;
row.EndTime = row.ServiceTime + row.StartTime;
sys.Servers[row.AssignedServer.ID - 1].currentEnd = row.EndTime;
lastEndTime = row.EndTime;
// chart calculations
// add the current working houers to this server
for (int i = row.StartTime; i < row.EndTime; i++)
{
sys.Servers[row.AssignedServer.ID - 1].workingHours.Add(i);
}
if (sys.stoppingCase == "NumberOfCustomers" || (sys.stoppingCase == "SimulationEndTime" && lastEndTime <= sys.StoppingNumber))
{
// performance calculations
sys.Servers[row.AssignedServer.ID - 1].totalServiceTime += row.ServiceTime;
sys.Servers[row.AssignedServer.ID - 1].noOfCustomers++;
sys.Servers[row.AssignedServer.ID - 1].serverCustomers.Add(row);
if (lastEndTime > totalSimulationTime)
{
totalSimulationTime = lastEndTime;
}
// this code is to calculate maximum queue length
if (row.TimeInQueue > 0)
{
queue.Add(row);
for (int i = 0; i < queue.Count; i++)
{
if (queue[queue.Count - 1].ArrivalTime >= queue[i].StartTime)
{
queue.Remove(queue[i]);
}
}
if (queue.Count > maxQueueLength)
{
maxQueueLength = queue.Count;
}
}
// update data grid view
customerGrid.Rows.Add(customersCount + 1, row.RandomInterArrival, row.InterArrival, row.ArrivalTime, row.RandomService, row.StartTime, row.ServiceTime, row.EndTime, row.TimeInQueue, row.AssignedServer.ID);
// add this customer to simulation table
sys.SimulationTable.Add(row);
customersCount++;
}
else
{
break;
}
}
// set final system performance measuers
sys.PerformanceMeasures.MaxQueueLength = maxQueueLength;
sys.PerformanceMeasures.AverageWaitingTime = (decimal)totalWaitingTime / customersCount;
sys.PerformanceMeasures.WaitingProbability = (decimal)NoOfCustomerWhoWaited / customersCount;
// set final servers perfomance
foreach (var server in sys.Servers)
{
if (server.noOfCustomers != 0)
{
server.AverageServiceTime = (decimal)server.totalServiceTime / server.noOfCustomers;
}
server.Utilization = (decimal)server.totalServiceTime / totalSimulationTime;
// set idle time for each server
if (server.serverCustomers.Count == 0)
{
server.idleTime = totalSimulationTime;
}
for (int i = 0; i < server.serverCustomers.Count; i++)
{
if (i == 0)
{
server.idleTime += sys.SimulationTable[0].ArrivalTime + server.serverCustomers[i].StartTime;
}
if ((i == server.serverCustomers.Count - 1) && (server.serverCustomers[i].EndTime != totalSimulationTime))
{
server.idleTime += Math.Abs(totalSimulationTime - server.serverCustomers[i].EndTime);
}
if (i == server.serverCustomers.Count - 1)
{
break;
}
server.idleTime += Math.Abs(server.serverCustomers[i].EndTime - server.serverCustomers[i + 1].StartTime);
}
server.IdleProbability = (decimal)server.idleTime / totalSimulationTime;
}
}
public void FillSimulationTable()
{
SimulationCase SimRow;
int shortageSum = 0;
int EndingInventoryTotal = 0;
int ShortageTotal = 0;
Random rand = new Random();
int cycleNumber = 1, cycleCounter = 1, index = 0, dummy = 0;
for (int day = 1; day <= simSys.NumberOfDays; day++)
{
//first 5 columns
SimRow = new SimulationCase();
SimRow.Day = day;
SimRow.Cycle = cycleNumber;
SimRow.DayWithinCycle = cycleCounter; // day % (simSys.ReviewPeriod + 1) + 1;
cycleCounter++;
if (cycleCounter > simSys.ReviewPeriod)
{
cycleCounter = 1;
cycleNumber++;
}
if (day == 1)
{
SimRow.BeginningInventory = simSys.StartInventoryQuantity;
SimRow.DaysUntillArrives = simSys.StartLeadDays - 1;
}
else
{
SimRow.DaysUntillArrives = simSys.SimulationTable[day - 2].DaysUntillArrives - 1;
if (SimRow.DaysUntillArrives == -1)
{
dummy++;
if (dummy == 1)//3shan 3aiza awl mara bs yst5dm start order quantity
{
SimRow.BeginningInventory = simSys.StartOrderQuantity + simSys.SimulationTable[day - 2].EndingInventory;
}
else
{
SimRow.BeginningInventory = simSys.SimulationTable[index - 1].OrderQuantity + simSys.SimulationTable[day - 2].EndingInventory;
}
}
else if (SimRow.DaysUntillArrives != -1)
{
SimRow.BeginningInventory = simSys.SimulationTable[day - 2].EndingInventory;
}
}
//Demand
int randomDemand = rand.Next(1, 101);
SimRow.RandomDemand = randomDemand;
for (int r = 0; r < simSys.DemandDistribution.Count; r++)
{
if (randomDemand >= simSys.DemandDistribution[r].MinRange && randomDemand <= simSys.DemandDistribution[r].MaxRange)
{
SimRow.Demand = simSys.DemandDistribution[r].Value;
break;
}
}
// Ending Inventory & shortage
if (SimRow.BeginningInventory >= SimRow.Demand)
{
if (shortageSum == 0)
{
SimRow.EndingInventory = SimRow.BeginningInventory - SimRow.Demand;
SimRow.ShortageQuantity = 0;
}
else if (shortageSum + SimRow.Demand > SimRow.BeginningInventory)
{
SimRow.EndingInventory = 0;
SimRow.ShortageQuantity = shortageSum + (SimRow.Demand - SimRow.BeginningInventory);
shortageSum = SimRow.ShortageQuantity;
}
else //there is shortage but less than or equal beginning Inventory
{
SimRow.EndingInventory = SimRow.BeginningInventory - SimRow.Demand - shortageSum;
SimRow.ShortageQuantity = 0;
shortageSum = 0;
}
}
else//demand>beginning Inventory
{
SimRow.EndingInventory = 0;
if (shortageSum == 0)//no shortage before
{
SimRow.ShortageQuantity = SimRow.Demand - SimRow.BeginningInventory;
shortageSum = SimRow.ShortageQuantity;
}
else //if there is shortage
{
SimRow.ShortageQuantity = shortageSum + (SimRow.Demand - SimRow.BeginningInventory);
shortageSum = SimRow.ShortageQuantity;
}
}
EndingInventoryTotal += SimRow.EndingInventory;
ShortageTotal += SimRow.ShortageQuantity;
// Order Quantity & lead time
if (SimRow.DayWithinCycle == simSys.ReviewPeriod)
{
SimRow.OrderQuantity = simSys.OrderUpTo - SimRow.EndingInventory + (SimRow.ShortageQuantity);
index = day;
SimRow.RandomLeadDays = rand.Next(1, 101);
for (int j = 0; j < simSys.LeadDaysDistribution.Count(); j++)
{
if (SimRow.RandomLeadDays >= simSys.LeadDaysDistribution[j].MinRange && SimRow.RandomLeadDays <= simSys.LeadDaysDistribution[j].MaxRange)
{
SimRow.LeadDays = simSys.LeadDaysDistribution[j].Value;
break;
}
}
SimRow.DaysUntillArrives = SimRow.LeadDays;
}
else
{
SimRow.OrderQuantity = 0;
SimRow.RandomLeadDays = 0;
SimRow.LeadDays = 0;
}
simSys.SimulationTable.Add(SimRow);
}
Performance(EndingInventoryTotal, ShortageTotal);
}
/// <summary>
/// Finds a server to sever the current simulation case
/// </summary>
/// <param name="Case">The current simulation case that needs to be served</param>
/// <param name="Servers">A list of all servers to search in</param>
/// <param name="SelectionMethod">The server selection method when multiple free servers are available</param>
static private void GetAssignedServer(SimulationCase Case, List <Server> Servers, Enums.SelectionMethod SelectionMethod)
{
int serverNum = 0;
int minServiceTime = Servers[0].FinishTime;
int minBigger = 0;
bool bigger = true;
decimal minUtilization = Servers[0].Utilization;
if (SelectionMethod == Enums.SelectionMethod.HighestPriority)
{
for (int i = 0; i < Servers.Count; i++)
{
if (Servers[i].FinishTime <= Case.ArrivalTime)
{
bigger = false;
}
if (Servers[i].FinishTime < minServiceTime)
{
minBigger = i;
minServiceTime = Servers[i].FinishTime;
}
}
if (bigger == true)
{
serverNum = minBigger;
}
else
{
for (int i = 0; i < Servers.Count; i++)
{
if (Servers[i].FinishTime <= Case.ArrivalTime)
{
minServiceTime = Servers[i].FinishTime;
serverNum = i;
break;
}
}
}
}
else if (SelectionMethod == Enums.SelectionMethod.LeastUtilization)
{
int minValue = Servers[0].FinishTime;
for (int i = 1; i < Servers.Count; i++)
{
minValue = Math.Min(Servers[i].FinishTime, minValue);
}
bool flag = false;
if (minValue < Case.ArrivalTime)
{
minValue = Case.ArrivalTime;
flag = true;
}
decimal leastUtil = decimal.MaxValue;
for (int i = 0; i < Servers.Count; i++)
{
if (flag)
{
if (Servers[i].FinishTime <= minValue && Servers[i].Utilization < leastUtil)
{
leastUtil = Servers[i].Utilization;
serverNum = i;
}
}
else
{
if (Servers[i].FinishTime == minValue && Servers[i].Utilization < leastUtil)
{
leastUtil = Servers[i].Utilization;
serverNum = i;
}
}
}
}
else
{
for (int i = 1; i < Servers.Count; i++)
{
if (Servers[i].FinishTime < minServiceTime)
{
minServiceTime = Servers[i].FinishTime;
serverNum = i;
}
}
}
Case.AssignedServer = Servers[serverNum];
Case.RandomService = rnd.Next(1, 100);
Case.ServiceTime = CalculateRandomValue(Servers[serverNum].TimeDistribution, Case.RandomService);
Case.StartTime = Math.Max(Servers[serverNum].FinishTime, Case.ArrivalTime);
Case.EndTime = Case.StartTime + Case.ServiceTime;
Case.TimeInQueue = Case.StartTime - Case.ArrivalTime;
Servers[serverNum].UtilizationTimes.Add(new KeyValuePair <int, int>(Case.StartTime, Case.EndTime));
Servers[serverNum].FinishTime = Case.StartTime + Case.ServiceTime;
Servers[serverNum].TotalWorkingTime += Case.ServiceTime;
Servers[serverNum].AverageServiceTime += Case.ServiceTime;
Servers[serverNum].ServedCount++;
}
public void fillSimCaseRow()
{
SimulationCase simRow = new SimulationCase();
Random randomNum = new Random();
simRow.CustomerNumber = 1;
simRow.RandomInterArrival = 1; //_
simRow.InterArrival = 1; //_
simRow.ArrivalTime = 0;
simRow.RandomService = randomNum.Next(1, 101);
simSys.SimulationTable.Add(simRow);
fillSimulationTable(0);
int i = 1;
while (true)
{
simRow = new SimulationCase();
simRow.CustomerNumber = i + 1;
simRow.RandomInterArrival = randomNum.Next(1, 101);
for (int j = 0; j < simSys.InterarrivalDistribution.Count; j++)
{
if (simRow.RandomInterArrival >= simSys.InterarrivalDistribution[j].MinRange && simRow.RandomInterArrival <= simSys.InterarrivalDistribution[j].MaxRange)
{
simRow.InterArrival = simSys.InterarrivalDistribution[j].Time;
break;
}
}
simRow.ArrivalTime = simSys.SimulationTable[i - 1].ArrivalTime + simRow.InterArrival;
simRow.RandomService = randomNum.Next(1, 101);//:) :)
if (simSys.StoppingCriteria == Enums.StoppingCriteria.SimulationEndTime)
{
if (simRow.ArrivalTime > simSys.StoppingNumber)
{
break;
}
}
if (simSys.StoppingCriteria == Enums.StoppingCriteria.NumberOfCustomers)
{
if (simSys.SimulationTable.Count < simSys.StoppingNumber)
{
simSys.SimulationTable.Add(simRow);
fillSimulationTable(i);
}
else
{
break;
}
}
else
{
simSys.SimulationTable.Add(simRow);
fillSimulationTable(i);
if (simSys.SimulationTable[i].EndTime > simSys.StoppingNumber)
{
simSys.SimulationTable.RemoveAt(i);
break;
}
}
i++;
}
}
private void Form1_Load(object sender, EventArgs e)
{
FileStream fs = new FileStream("TestCase1.txt", FileMode.Open);
StreamReader sr = new StreamReader(fs);
while (sr.Peek() != -1)
{
string fineline = sr.ReadLine();
if (fineline == "")
{
continue;
}
else if (fineline == "NumberOfServers")
{
mysystem.NumberOfServers = int.Parse(sr.ReadLine());
}
else if (fineline == "StoppingNumber")
{
mysystem.StoppingNumber = int.Parse(sr.ReadLine());
}
else if (fineline == "StoppingCriteria")
{
int x = int.Parse(sr.ReadLine());
if (x == 1)
{
mysystem.StoppingCriteria = Enums.StoppingCriteria.NumberOfCustomers;
}
else
{
mysystem.StoppingCriteria = Enums.StoppingCriteria.SimulationEndTime;
}
}
else if (fineline == "SelectionMethod")
{
int y = int.Parse(sr.ReadLine());
if (y == 1)
{
mysystem.SelectionMethod = Enums.SelectionMethod.HighestPriority;
}
else if (y == 2)
{
mysystem.SelectionMethod = Enums.SelectionMethod.Random;
}
else
{
mysystem.SelectionMethod = Enums.SelectionMethod.LeastUtilization;
}
}
else if (fineline == "InterarrivalDistribution")
{
int cp = 0;
while (true)
{
string td = sr.ReadLine();
if (td == "")
{
break;
}
string[] l = td.Split(',');
TimeDistribution x = new TimeDistribution();
x.Time = int.Parse(l[0]);
int pro = Convert.ToInt32(float.Parse(l[1]) * 100);
x.Probability = pro;
x.CummProbability = cp + pro;
x.MinRange = cp + 1;
cp += pro;
x.MaxRange = cp;
mysystem.InterarrivalDistribution.Add(x);
}
}
else if (fineline.Contains("ServiceDistribution_Server"))
{
for (int i = 0; i < mysystem.NumberOfServers; i++)
{
Server min = new Server();
min.ID = i + 1;
min.FinishTime = 0;
int cp = 0;
while (true)
{
string td = sr.ReadLine();
if (td == "" || td == null)
{
sr.ReadLine();
break;
}
string[] l = td.Split(',');
TimeDistribution x = new TimeDistribution();
x.Time = int.Parse(l[0]);
int pro = Convert.ToInt32(float.Parse(l[1]) * 100);
x.Probability = pro;
x.CummProbability = cp + pro;
x.MinRange = cp + 1;
cp += pro;
x.MaxRange = cp;
min.TimeDistribution.Add(x);
}
mysystem.Servers.Add(min);
}
}
//string[] l = sr.ReadLine().Split(',');
//TimeDistribution x = new TimeDistribution();
//x.Time = int.Parse(l[0]);
//x.Probability = int.Parse(l[1]);
//x.CummProbability = int.Parse(l[2]);
//x.MinRange = int.Parse(l[3]);
//x.MaxRange = int.Parse(l[4]);
//TimeDistribution x = new TimeDistribution();
//List < TimeDistribution > inter = x.gettable();
//List<TimeDistribution> able = x.gettable_able();
//List<TimeDistribution> baker = x.gettable_baker();
}
fs.Close();
if (mysystem.StoppingCriteria == Enums.StoppingCriteria.NumberOfCustomers)
{
Random rnd = new Random();
Random rndforservice = new Random();
Random rndservers = new Random();
int artime = 0;
for (int i = 0; i < mysystem.StoppingNumber; i++)
{
SimulationCase row = new SimulationCase();
if (i == 0)
{
row.CustomerNumber = 1;
row.InterArrival = 0;
row.ArrivalTime = 0;
row.RandomInterArrival = 1;
int st = rndforservice.Next(1, 100);
row.RandomService = st;
int id = 0;
if (mysystem.SelectionMethod == Enums.SelectionMethod.HighestPriority)
{
id = 0;
}
else if (mysystem.SelectionMethod == Enums.SelectionMethod.Random)
{
id = rndservers.Next(0, mysystem.NumberOfServers);
}
row.ServiceTime = getim(st, mysystem.Servers[id].TimeDistribution);
row.AssignedServer = mysystem.Servers[id];
mysystem.Servers[id].FinishTime = row.ServiceTime;
mysystem.Servers[id].TotalWorkingTime += row.ServiceTime;
row.StartTime = 0;
row.EndTime = row.ServiceTime;
row.TimeInQueue = 0;
mysystem.SimulationTable.Add(row);
}
else
{
row.CustomerNumber = i + 1;
row.RandomInterArrival = rnd.Next(1, 100);
row.InterArrival = getim(row.RandomInterArrival, mysystem.InterarrivalDistribution);
artime += row.InterArrival;
row.ArrivalTime = artime;
int st = rndforservice.Next(1, 100);
row.RandomService = st;
int sr_id = 0;
if (mysystem.SelectionMethod == Enums.SelectionMethod.HighestPriority)
{
sr_id = get_server(mysystem.Servers, row.ArrivalTime);
}
else if (mysystem.SelectionMethod == Enums.SelectionMethod.Random)
{
sr_id = get_server_rc(mysystem.Servers, row.ArrivalTime);
}
else if (mysystem.SelectionMethod == Enums.SelectionMethod.LeastUtilization)
{
sr_id = least_ut();
}
row.ServiceTime = getim(st, mysystem.Servers[sr_id].TimeDistribution);
row.StartTime = maxx(mysystem.Servers[sr_id].FinishTime, row.ArrivalTime);
row.EndTime = row.StartTime + row.ServiceTime;
row.TimeInQueue = row.StartTime - row.ArrivalTime;
row.AssignedServer = mysystem.Servers[sr_id];
mysystem.Servers[sr_id].FinishTime = row.EndTime;
mysystem.Servers[sr_id].TotalWorkingTime += row.ServiceTime;
mysystem.SimulationTable.Add(row);
}
}
}
else if (mysystem.StoppingCriteria == Enums.StoppingCriteria.SimulationEndTime)
{
Random rnd = new Random();
Random rndforservice = new Random();
Random rndservers = new Random();
int artime = 0;
int ghg = 1;
while (artime < mysystem.StoppingNumber)
{
SimulationCase row = new SimulationCase();
if (artime == 0)
{
row.CustomerNumber = 1;
row.InterArrival = 0;
row.ArrivalTime = 0;
row.RandomInterArrival = 1;
int st = rndforservice.Next(1, 100);
row.RandomService = st;
if (mysystem.SelectionMethod == Enums.SelectionMethod.HighestPriority)
{
row.ServiceTime = getim(st, mysystem.Servers[0].TimeDistribution);
row.AssignedServer = mysystem.Servers[0];
mysystem.Servers[0].FinishTime = row.ServiceTime;
mysystem.Servers[0].TotalWorkingTime += row.ServiceTime;
}
else if (mysystem.SelectionMethod == Enums.SelectionMethod.Random)
{
int id = rndservers.Next(0, mysystem.NumberOfServers);
row.ServiceTime = getim(st, mysystem.Servers[id].TimeDistribution);
row.AssignedServer = mysystem.Servers[id];
mysystem.Servers[id].FinishTime = row.ServiceTime;
mysystem.Servers[id].TotalWorkingTime += row.ServiceTime;
}
row.StartTime = 0;
row.EndTime = row.ServiceTime;
row.TimeInQueue = 0;
mysystem.SimulationTable.Add(row);
}
else
{
row.CustomerNumber = ghg;
ghg += 1;
row.RandomInterArrival = rnd.Next(1, 100);
row.InterArrival = getim(row.RandomInterArrival, mysystem.InterarrivalDistribution);
artime += row.InterArrival;
row.ArrivalTime = artime;
int st = rndforservice.Next(1, 100);
row.RandomService = st;
int sr_id = 0;
if (mysystem.SelectionMethod == Enums.SelectionMethod.HighestPriority)
{
sr_id = get_server(mysystem.Servers, row.ArrivalTime);
}
else if (mysystem.SelectionMethod == Enums.SelectionMethod.Random)
{
sr_id = get_server_rc(mysystem.Servers, row.ArrivalTime);
}
else if (mysystem.SelectionMethod == Enums.SelectionMethod.LeastUtilization)
{
sr_id = least_ut();
}
row.ServiceTime = getim(st, mysystem.Servers[sr_id].TimeDistribution);
row.StartTime = maxx(mysystem.Servers[sr_id].FinishTime, row.ArrivalTime);
row.EndTime = row.StartTime + row.ServiceTime;
row.TimeInQueue = row.StartTime - row.ArrivalTime;
row.AssignedServer = mysystem.Servers[sr_id];
mysystem.Servers[sr_id].FinishTime = row.EndTime;
mysystem.Servers[sr_id].TotalWorkingTime += row.ServiceTime;
mysystem.SimulationTable.Add(row);
}
}
}
int cou = 0;
int wait_prob = 0;
for (int v = 0; v < mysystem.SimulationTable.Count; v++)
{
if (mysystem.SimulationTable[v].TimeInQueue > 0)
{
wait_prob += 1;
}
cou += mysystem.SimulationTable[v].TimeInQueue;
}
decimal n = (decimal)cou / mysystem.SimulationTable.Count;
mysystem.PerformanceMeasures.AverageWaitingTime = n;
n = (decimal)wait_prob / mysystem.SimulationTable.Count;
mysystem.PerformanceMeasures.WaitingProbability = n;
mysystem.PerformanceMeasures.MaxQueueLength = max_q_len(mysystem.SimulationTable);
List <int> myli = avg_st(mysystem.SimulationTable, mysystem.NumberOfServers);
for (int u = 0; u < mysystem.NumberOfServers; u++)
{
if (myli[u] == 0)
{
mysystem.Servers[u].AverageServiceTime = 0;
}
else
{
mysystem.Servers[u].AverageServiceTime = (decimal)mysystem.Servers[u].TotalWorkingTime / myli[u];
}
int dif = max_finish(mysystem.Servers) - mysystem.Servers[u].TotalWorkingTime;
mysystem.Servers[u].IdleProbability = (decimal)dif / max_finish(mysystem.Servers);
mysystem.Servers[u].Utilization = (decimal)mysystem.Servers[u].TotalWorkingTime / max_finish(mysystem.Servers);
}
for (int s = 0; s < mysystem.NumberOfServers; s++)
{
comboBox1.Items.Add(s + 1);
}
comboBox1.SelectedItem = comboBox1.Items[0];
MessageBox.Show(TestingManager.Test(mysystem, Constants.FileNames.TestCase1));
var binding = new BindingList <SimulationCase>(mysystem.SimulationTable);
var src = new BindingSource(binding, null);
dataGridView1.DataSource = src;
}
