public static void calculate_delay_time(DataGridView dataGridView2)
{
decimal cum2_temp = 0;
for (int i = 0; i < dataGridView2.RowCount - 1; i++)
{
TimeDistribution temp = new TimeDistribution();
int j = 0;
temp.Time = Convert.ToInt32(dataGridView2[j, i].Value);
temp.Probability = Convert.ToDecimal(dataGridView2[j + 1, i].Value);
cum2_temp += temp.Probability;
if (i == 0)
{
temp.CummProbability = temp.Probability;
temp.MinRange = 1;
}
else
{
temp.CummProbability = cum2_temp;
temp.MinRange = mysystem.DelayTimeDistribution[i - 1].MaxRange + 1;
}
temp.MaxRange = (int)(temp.CummProbability * 100);
dataGridView2.Rows[i].Cells[2].Value = cum2_temp;
dataGridView2.Rows[i].Cells[3].Value = temp.MinRange;
dataGridView2.Rows[i].Cells[4].Value = temp.MaxRange;
mysystem.DelayTimeDistribution.Add(temp);
}
}
public void ReadFromFile()
{
string FileContent = File.ReadAllText("C:\\Users\\Nour\\Desktop\\MultiQueue System\\SimulationTask1\\MultiQueueSimulation\\TestCases\\TestCase1.txt");
string[] Lines = FileContent.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
App.SimulationSystem.NumberOfServers = Convert.ToInt32(Lines[1]);
for (int i = 0; i < App.SimulationSystem.NumberOfServers; i++)
{
Server Temp = new Server()
{
ID = i + 1
};
App.SimulationSystem.Servers.Add(Temp);
}
App.SimulationSystem.StoppingNumber = Convert.ToInt32(Lines[4]);
App.SimulationSystem.StoppingCriteria = (Enums.StoppingCriteria)Enum.ToObject(typeof(Enums.StoppingCriteria), Convert.ToInt32(Lines[7]));
App.SimulationSystem.SelectionMethod = (Enums.SelectionMethod)Enum.ToObject(typeof(Enums.SelectionMethod), Convert.ToInt32(Lines[10]));
int index = 13;
while (!String.IsNullOrWhiteSpace(Lines[index]))
{
string[] halfline = Lines[index].Split(',');
TimeDistribution temp = new TimeDistribution
{
Time = Convert.ToInt32(halfline[0]),
Probability = Convert.ToDecimal(halfline[1]),
};
App.SimulationSystem.InterarrivalDistribution.Add(temp);
index++;
}
for (int q = 0; q < App.SimulationSystem.NumberOfServers; q++)
{
index += 2;
while (!String.IsNullOrWhiteSpace(Lines[index]))
{
string[] halfline = Lines[index].Split(',');
TimeDistribution temp = new TimeDistribution
{
Time = Convert.ToInt32(halfline[0]),
Probability = Convert.ToDecimal(halfline[1]),
};
App.SimulationSystem.Servers[q].TimeDistribution.Add(temp);
index++;
if (index == Lines.Length)
{
break;
}
}
}
Thread t = new Thread(new ThreadStart(FileProc));
t.Start();
Thread.Sleep(150);
if (t.IsAlive)
{
t.Abort();
}
}
public void fillSimSysObj(string[] sysData)
{
simSys.DowntimeCost = Convert.ToInt32(sysData[1]);
simSys.RepairPersonCost = Convert.ToInt32(sysData[4]);
simSys.BearingCost = Convert.ToInt32(sysData[7]);
simSys.NumberOfHours = Convert.ToInt32(sysData[10]);
simSys.NumberOfBearings = Convert.ToInt32(sysData[13]);
simSys.RepairTimeForOneBearing = Convert.ToInt32(sysData[16]);
simSys.RepairTimeForAllBearings = Convert.ToInt32(sysData[19]);
int i = 22;
while (sysData[i] != "")
{
string[] line = sysData[i].Split(new string[] { ", " }, StringSplitOptions.None);
TimeDistribution delayTimeDistribution = new TimeDistribution();
delayTimeDistribution.Time = Convert.ToInt32(line[0]);
delayTimeDistribution.Probability = Convert.ToDecimal(line[1]);
simSys.DelayTimeDistribution.Add(delayTimeDistribution);
i++;
}
i += 2;
while (i != sysData.Length)
{
string[] line = sysData[i].Split(new string[] { ", " }, StringSplitOptions.None);
TimeDistribution bearingTimeDistribution = new TimeDistribution();
bearingTimeDistribution.Time = Convert.ToInt32(line[0]);
bearingTimeDistribution.Probability = Convert.ToDecimal(line[1]);
simSys.BearingLifeDistribution.Add(bearingTimeDistribution);
i++;
}
}
private void Next_Click(object sender, EventArgs e)
{
int Range = 1;
decimal cumulative = 0;
Server current = new Server();
current.ID = Program.Servers.Count + 1;
for (int rows = 0; rows < ServerGrid.RowCount - 1; rows++)
{
TimeDistribution tmp = new TimeDistribution();
tmp.Time = Int32.Parse(ServerGrid.Rows[rows].Cells[0].Value.ToString());
tmp.Probability = Decimal.Parse(ServerGrid.Rows[rows].Cells[1].Value.ToString());
tmp.CummProbability = tmp.Probability + cumulative;
cumulative = tmp.CummProbability;
tmp.MinRange = Range + 1;
tmp.MaxRange = Convert.ToInt32(cumulative * 100);
Range = tmp.MaxRange;
current.TimeDistribution.Add(tmp);
}
Program.Servers.Add(current);
if (Count == 0)
{
Results form = new Results(ref Program);
form.Show();
this.Close();
}
else
{
ServerForm form = new ServerForm(ref Program, Count - 1);
form.Show();
this.Close();
}
}
private static void RecieveData(Socket socket, SimulationSystem system)
{
byte[] buffer = new byte[1024];
int n = socket.Receive(buffer);
system.DowntimeCost = int.Parse(Encoding.ASCII.GetString(buffer, 0, n));
n = socket.Receive(buffer);
system.RepairPersonCost = int.Parse(Encoding.ASCII.GetString(buffer, 0, n));
n = socket.Receive(buffer);
system.BearingCost = int.Parse(Encoding.ASCII.GetString(buffer, 0, n));
n = socket.Receive(buffer);
system.NumberOfHours = int.Parse(Encoding.ASCII.GetString(buffer, 0, n));
n = socket.Receive(buffer);
system.NumberOfBearings = int.Parse(Encoding.ASCII.GetString(buffer, 0, n));
n = socket.Receive(buffer);
system.RepairTimeForOneBearing = int.Parse(Encoding.ASCII.GetString(buffer, 0, n));
n = socket.Receive(buffer);
system.RepairTimeForAllBearings = int.Parse(Encoding.ASCII.GetString(buffer, 0, n));
n = socket.Receive(buffer);
foreach (List <TimeDistribution> l in new List <TimeDistribution>[] { system.DelayTimeDistribution, system.BearingLifeDistribution })
{
int len = int.Parse(Encoding.ASCII.GetString(buffer, 0, n));
for (int i = 0; i < len; i++)
{
TimeDistribution distribution = new TimeDistribution();
n = socket.Receive(buffer);
int time = int.Parse(Encoding.ASCII.GetString(buffer, 0, n));
n = socket.Receive(buffer);
decimal probability = decimal.Parse(Encoding.ASCII.GetString(buffer, 0, n));
distribution.Time = time;
distribution.Probability = probability;
l.Add(distribution);
}
}
}
private void ResetToDefaultValues()
{
TimeDistribution td = agentsManager.GetComponent("TimeDistribution") as TimeDistribution;
maxLife = Mathf.FloorToInt(td.TimeInDay) * 15;
staminaUpdateTime = Mathf.FloorToInt(td.TimeInDay);
nextStaminaUpdate = ((nextStaminaUpdate - Mathf.FloorToInt(Time.time))) + Mathf.FloorToInt(Time.time) + Mathf.FloorToInt(staminaUpdateTime);
}
//loading input into each server's service time dist table and interarrival time dist table
private void SimBtn_Click(object sender, EventArgs e)
{
List <Server> Servers = new List <Server>();
// server[0] contains the time distrubution of interarivaltime throughout the entire program
int Cols = 0;
for (int i = 0; i < NoServers; i++)
{
Server new_server = new Server();
Servers.Add(new_server);
new_server.ServiceTimeDistribution = new List <TimeDistribution>();
for (int j = 0; j < InputGrdView.RowCount; j++)
{ //we should check if cells are not empty
// add a new service time dist row in the current server
if (InputGrdView.Rows[j].Cells[Cols].Value != null)
{
TimeDistribution new_td = new TimeDistribution(); //new row
Servers[i].ServiceTimeDistribution.Add(new_td);
Servers[i].ServiceTimeDistribution[j].Time = Int32.Parse(InputGrdView.Rows[j].Cells[Cols].Value.ToString());
Servers[i].ServiceTimeDistribution[j].Probability = double.Parse(InputGrdView.Rows[j].Cells[Cols + 1].Value.ToString());
}
}
Cols += 2;
}
SimSystem.CompleteServiceTimeDistributionData(NoServers, InputGrdView.RowCount, Servers);
Enums.ServerSelectionMethod SelectionMethod = new Enums.ServerSelectionMethod();
Enums.ServerStoppingCondition StoppingCondition = new Enums.ServerStoppingCondition();
if (PriorityRadioBtn.Checked)
{
SelectionMethod = Enums.ServerSelectionMethod.HighestPriority;
}
else if (RandomRadioBtn.Checked)
{
SelectionMethod = Enums.ServerSelectionMethod.Random;
}
else if (LeastUtiRadioBtn.Checked)
{
SelectionMethod = Enums.ServerSelectionMethod.LowestUtilization;
}
if (MaxNoRadioBtn.Checked)
{
StoppingCondition = Enums.ServerStoppingCondition.NumberOfCustomers;
List <SimualtionCase> result = SimSystem.Simulate(SelectionMethod, StoppingCondition, MaxNoTxtbox.Text);
show_results(result);
}
else if (SimEndTimeRadioBtn.Checked)
{
StoppingCondition = Enums.ServerStoppingCondition.SimulationEndTime;
List <SimualtionCase> result = SimSystem.Simulate(SelectionMethod, StoppingCondition, SimTimeTxtbox.Text);
show_results(result);
}
}
void Awake()
{
if (agentBehaviours == null)
{
agentBehaviours = gameObject.GetComponent <AgentBehaviourLibrary>();
}
if (timeDistribution = null)
{
timeDistribution = gameObject.transform.parent.GetComponent("TimeDistribution") as TimeDistribution;
}
}
private void button4_Click(object sender, EventArgs e)
{
inp.Input.NumberOfServers = int.Parse(txt_servernum.Text);
inp.Input.StoppingNumber = int.Parse(txt_stoppnum.Text);
inp.Input.SelectionMethod = method_cmb.SelectedIndex + 1;
inp.Input.StoppingCriterea = criterea_cmb.SelectedIndex + 1;
List <TimeDistribution> InterArrival = new List <TimeDistribution>();
for (int i = 0; i < dataGridView1.RowCount - 1; i++)
{
TimeDistribution t = new TimeDistribution();
t.Time = int.Parse(dataGridView1.Rows[i].Cells[0].Value.ToString());
t.Probability = Convert.ToDecimal(dataGridView1.Rows[i].Cells[1].Value.ToString());
InterArrival.Add(t);
}
inp.InterarrivalDistribution = InterArrival;
}
void Start()
{
UpdateFoodList();
int i = foodAvailable.Count;
while (i < maxFood)
{
SpawnFood();
i++;
}
if (agentsManager)
{
td = agentsManager.GetComponent("TimeDistribution") as TimeDistribution;
restockTime = td.TimeInDay * 3;
}
}
private int UpdateWorkList(GameObject[] agentsArray, int nextWorkUpdate, ref int worksIndex)
{
if (Time.time >= nextWorkUpdate) // Time to pick a new work
{
TimeDistribution timeDistribution = gameObject.GetComponent("TimeDistribution") as TimeDistribution;
worksIndex++;
if (worksIndex >= 3)
{
if (!isNight) // Completed all possible work orders
{
worksIndex = 0;
}
else
{
worksIndex = 3;
}
}
switch (worksIndex)
{
case 0:
nextWorkUpdate = UpdateTime(timeDistribution.FoodTime, nextWorkUpdate);
break;
case 1:
nextWorkUpdate = UpdateTime(timeDistribution.BridgesTime, nextWorkUpdate);
break;
case 2:
nextWorkUpdate = UpdateTime(timeDistribution.HousesTime, nextWorkUpdate);
break;
case 3:
nextWorkUpdate = UpdateTime(timeDistribution.ProcreationTime, nextWorkUpdate);
break;
}
AlertAgents(agentsArray, worksIndex);
return(nextWorkUpdate);
}
return(nextWorkUpdate);
}
void TakeInput()
{
string[] lines = File.ReadAllLines(openFileDialog1.FileName);
simulationSystem.DowntimeCost = Convert.ToInt32(lines[1]);
simulationSystem.RepairPersonCost = Convert.ToInt32(lines[4]);
simulationSystem.BearingCost = Convert.ToInt32(lines[7]);
simulationSystem.NumberOfHours = Convert.ToInt32(lines[10]);
simulationSystem.NumberOfBearings = Convert.ToInt32(lines[13]);
simulationSystem.RepairTimeForOneBearing = Convert.ToInt32(lines[16]);
simulationSystem.RepairTimeForAllBearings = Convert.ToInt32(lines[19]);
int i = 22;
decimal lst = 0;
for (; lines[i] != ""; i++)
{
string[] separator = { ", " };
string[] values = lines[i].Split(separator, 2, StringSplitOptions.RemoveEmptyEntries);
TimeDistribution td = new TimeDistribution();
td.Time = Convert.ToInt32(values[0]);
td.Probability = Convert.ToDecimal(values[1]);
td.CummProbability = lst + td.Probability;
td.MinRange = Convert.ToInt32(lst * 100) + 1;
lst = td.CummProbability;
td.MaxRange = Convert.ToInt32(lst * 100);
simulationSystem.DelayTimeDistribution.Add(td);
}
i += 2;
lst = 0;
for (; i < lines.Length; i++)
{
string[] separator = { ", " };
string[] values = lines[i].Split(separator, 2, StringSplitOptions.RemoveEmptyEntries);
TimeDistribution td = new TimeDistribution();
td.Time = Convert.ToInt32(values[0]);
td.Probability = Convert.ToDecimal(values[1]);
td.CummProbability = lst + td.Probability;
td.MinRange = Convert.ToInt32(lst * 100) + 1;
lst = td.CummProbability;
td.MaxRange = Convert.ToInt32(lst * 100);
simulationSystem.BearingLifeDistribution.Add(td);
}
}
// Use this for initialization
void Start()
{
agentsCreator = gameObject.GetComponent("AgentsCreator") as AgentsCreator;
agentsManager = gameObject.GetComponent("AgentsManager") as AgentsManager;
deathsHandler = gameObject.GetComponent("AgentsDeathsHandler") as AgentsDeathsHandler;
timeDistribution = gameObject.GetComponent("TimeDistribution") as TimeDistribution;
populationCounterTxt = populationCounterTxtbox.GetComponent <Text>();
populationCounterTxt = populationCounterTxtbox.GetComponent <Text>();
infantsCounterTxt = infantsCounterTxtbox.GetComponent <Text>();
eatenCounterTxt = eatenCounterTxtbox.GetComponent <Text>();
starvedCounterTxt = starvedCounterTxtbox.GetComponent <Text>();
deathsCounterTxt = deathsCounterTxtbox.GetComponent <Text>();
averageLifespaneTxt = averageLifespanTxtbox.GetComponent <Text>();
daysPassedTxt = daysPassedTxtbox.GetComponent <Text>();
scoreManager = HSManager.GetComponent("ScoreManager") as ScoreManager;
}
private void Next_Click(object sender, EventArgs e)
{
int Range = 1;
decimal cumulative = 0;
for (int rows = 0; rows < ClientGrid.RowCount - 1; rows++)
{
TimeDistribution tmp = new TimeDistribution();
tmp.Time = Int32.Parse(ClientGrid.Rows[rows].Cells[0].Value.ToString());
tmp.Probability = Decimal.Parse(ClientGrid.Rows[rows].Cells[1].Value.ToString());
cumulative += tmp.Probability;
tmp.MinRange = Range;
tmp.MaxRange = (int)(cumulative * 100);
tmp.CummProbability = cumulative;
Range = tmp.MaxRange + 1;
Program.InterarrivalDistribution.Add(tmp);
}
int Count = Int32.Parse(ServersCount.Text);
Program.NumberOfServers = Count;
ServerForm form = new ServerForm(ref Program, Count - 1);
form.Show();
}
private void button5_Click(object sender, EventArgs e)
{
int j = int.Parse(txt_servernum.Text);
j--;
txt_servernum.Text = j.ToString();
if (j == 0)
{
inp.Input.ServersList = servers;
button5.Enabled = false;
}
List <TimeDistribution> ServerDistribution = new List <TimeDistribution>();
Server S = new Server();
for (int i = 0; i < dataGridView2.RowCount - 1; i++)
{
TimeDistribution t = new TimeDistribution();
t.Time = int.Parse(dataGridView2.Rows[i].Cells[0].Value.ToString());
t.Probability = Convert.ToDecimal(dataGridView2.Rows[i].Cells[1].Value.ToString());
ServerDistribution.Add(t);
S.TimeDistribution = ServerDistribution;
}
servers.Add(S);
}
// Use this for initialization
void Start()
{
numberOfBots = numberOfBots + 1;
botNumber = numberOfBots;
agentsManager = transform.parent.gameObject;
agentBehaviours = gameObject.GetComponent <AgentBehaviourLibrary>();
timeDistribution = gameObject.transform.parent.GetComponent("TimeDistribution") as TimeDistribution;
dateBorn = timeDistribution.DaysPassed;
nextStaminaUpdate = timeDistribution.TimeInDay;
staminaUpdateTime = timeDistribution.TimeInDay / 1.75f;
SetRandomAge();
defaultColor = new Color(0, 1, 1, 1);
GetComponent <SpriteRenderer>().color = defaultColor;
worksIndex = Random.Range(-2, 3) + 1;
FindHouse();
agentBehaviours.SetBotNumber(botNumber);
}
public void Read_input(string FileName = "TestCase2")
{
FileName += ".txt";
//string TestPath = Directory.GetParent(Environment.CurrentDirectory).Parent.FullName+"\\MultiQueueSimulation\\MultiQueueSimulation\\TestCases";
FileStream F = new FileStream(FileName, FileMode.Open);
StreamReader R = new StreamReader(F);
R.ReadLine();
sys.NumberOfServers = int.Parse(R.ReadLine());
R.ReadLine();
R.ReadLine();
sys.StoppingNumber = int.Parse(R.ReadLine());
R.ReadLine();
R.ReadLine();
stopCri = int.Parse(R.ReadLine());
if (stopCri == 1)
{
sys.StoppingCriteria = Enums.StoppingCriteria.NumberOfCustomers;
}
else
{
sys.StoppingCriteria = Enums.StoppingCriteria.SimulationEndTime;
}
R.ReadLine();
R.ReadLine();
selecMeth = int.Parse(R.ReadLine());
if (selecMeth == 1)
{
sys.SelectionMethod = Enums.SelectionMethod.HighestPriority;
}
else if (selecMeth == 2)
{
sys.SelectionMethod = Enums.SelectionMethod.Random;
}
else
{
sys.SelectionMethod = Enums.SelectionMethod.LeastUtilization;
}
R.ReadLine();
R.ReadLine();
string line;
char[] spearator = { ',', ' ' };
while ((line = R.ReadLine()) != "")
{
TimeDistribution temp = new TimeDistribution();
string[] l = line.Split(spearator);
temp.Time = int.Parse(l[0]);
temp.Probability = decimal.Parse(l[2]);
sys.InterarrivalDistribution.Add(temp);
}
R.ReadLine();
for (int i = 1; i <= sys.NumberOfServers; i++)
{
Server serTemp = new Server();
serTemp.ID = i;
serTemp.FinishTime = 0;
serTemp.Utilization = 0;
while ((line = R.ReadLine()) != "" && (line != " "))
{
if (line == null)
{
break;
}
TimeDistribution temp = new TimeDistribution();
string[] l = line.Split(spearator);
temp.Time = int.Parse(l[0]);
temp.Probability = decimal.Parse(l[2]);
serTemp.TimeDistribution.Add(temp);
}
sys.Servers.Add(serTemp);
if (line == null)
{
break;
}
R.ReadLine();
}
}
private void getDataFromGUI_Click(object sender, EventArgs e)
{
simSys.NumberOfServers = Convert.ToInt32(noOfServerstextBox.Text);
simSys.StoppingNumber = Convert.ToInt32(stoppingNotextBox.Text);
if (noOfCustomersradioButton.Checked)
{
simSys.StoppingCriteria = Enums.StoppingCriteria.NumberOfCustomers;
}
else if (simEndTimeradioButton.Checked)
{
simSys.StoppingCriteria = Enums.StoppingCriteria.SimulationEndTime;
}
if (highestPriorityradioButton.Checked)
{
simSys.SelectionMethod = Enums.SelectionMethod.HighestPriority;
}
else if (randomradioButton.Checked)
{
simSys.SelectionMethod = Enums.SelectionMethod.Random;
}
else if (leastUtilizationradioButton.Checked)
{
simSys.SelectionMethod = Enums.SelectionMethod.LeastUtilization;
}
string intervalDistFromTextBox = InterarrivalDistributiontextbox.Text;
string[] intervalDist = intervalDistFromTextBox.Split(new[] { "\r\n", "\r", "\n", ",", " " }, StringSplitOptions.None);
intervalDist = intervalDist.Where(w => w != "").ToArray();
TimeDistribution timeDistribution;
for (int i = 0; i < intervalDist.Length; i += 2)
{
timeDistribution = new TimeDistribution();
timeDistribution.Time = Convert.ToInt32(intervalDist[i]);
timeDistribution.Probability = Convert.ToDecimal(intervalDist[i + 1]);
simSys.InterarrivalDistribution.Add(timeDistribution);
}
string serviceDistFromTextBox = serviceDistributiontextBox.Text;
string[] serviceDist = serviceDistFromTextBox.Split(new[] { "\r\n", "\r", "\n", ",", " " }, StringSplitOptions.None);
serviceDist = serviceDist.Where(w => w != "").ToArray();
Server server;
int k = 1;
for (int i = 0; i < simSys.NumberOfServers; i++)
{
server = new Server();
server.ID = i + 1;
while (k != serviceDist.Length)
{
try
{
int x = Convert.ToInt32(serviceDist[k]);
}
catch
{
break;
}
timeDistribution = new TimeDistribution();
timeDistribution.Time = Convert.ToInt32(serviceDist[k]);
timeDistribution.Probability = Convert.ToDecimal(serviceDist[k + 1]);
server.TotalWorkingTime = 0;
server.FinishTime = 0;
server.TimeDistribution.Add(timeDistribution);
k += 2;
}
k++;
simSys.Servers.Add(server);
}
fillInterArrivaleTable();
fillServersTimeDistribution();
fillSimCaseRow();
systemCalculations();
serverCalculations();
// simSys.PerformanceMeasures.MaxQueueLength = 3;
string testingResult = TestingManager.Test(simSys, Constants.FileNames.TestCase1);
MessageBox.Show(testingResult);
Form2 f2 = new Form2();
f2.Show();
this.Hide();
}
public void fillSimSysObj(string[] sysData)
{
simSys.NumberOfServers = Convert.ToInt32(sysData[1]);
simSys.Servers = new List <Server>(simSys.NumberOfServers);
simSys.SimulationTable = new List <SimulationCase>();
simSys.StoppingNumber = Convert.ToInt32(sysData[4]);
if (Convert.ToInt32(sysData[7]) == 1)
{
simSys.StoppingCriteria = Enums.StoppingCriteria.NumberOfCustomers;
}
else
{
simSys.StoppingCriteria = Enums.StoppingCriteria.SimulationEndTime;
}
if (Convert.ToInt32(sysData[10]) == 1)
{
simSys.SelectionMethod = Enums.SelectionMethod.HighestPriority;
}
else if (Convert.ToInt32(sysData[10]) == 2)
{
simSys.SelectionMethod = Enums.SelectionMethod.Random;
}
else
{
simSys.SelectionMethod = Enums.SelectionMethod.LeastUtilization;
}
int i = 13;
while (sysData[i] != "")
{
string[] line = sysData[i].Split(new string[] { ", " }, StringSplitOptions.None);
TimeDistribution timeDistributionRow = new TimeDistribution();
timeDistributionRow.Time = Convert.ToInt32(line[0]);
timeDistributionRow.Probability = Convert.ToDecimal(line[1]);
simSys.InterarrivalDistribution.Add(timeDistributionRow);
i++;
}
for (int j = 0; j < simSys.NumberOfServers; j++)
{
i += 2;
Server server = new Server();
server.ID = j + 1;
while (i != sysData.Length && sysData[i] != "")
{
string[] line = sysData[i].Split(new string[] { ", " }, StringSplitOptions.None);
TimeDistribution timeDistributionRow = new TimeDistribution();
timeDistributionRow.Time = Convert.ToInt32(line[0]);
timeDistributionRow.Probability = Convert.ToDecimal(line[1]);
server.TotalWorkingTime = 0;
server.FinishTime = 0;
server.TimeDistribution.Add(timeDistributionRow);
i++;
}
simSys.Servers.Add(server);
}
}
public void read_file()
{
string[] lines = System.IO.File.ReadAllLines("TestCase3.txt"); // read lines
sys.NumberOfServers = int.Parse(lines[1]);
sys.StoppingNumber = int.Parse(lines[4]);
if (lines[7] == "1")
{
sys.StoppingCriteria = Enums.StoppingCriteria.NumberOfCustomers;
}
else
{
sys.StoppingCriteria = Enums.StoppingCriteria.SimulationEndTime;
}
if (lines[10] == "1")
{
sys.SelectionMethod = Enums.SelectionMethod.HighestPriority;
}
else if (lines[10] == "2")
{
sys.SelectionMethod = Enums.SelectionMethod.Random;
}
else
{
sys.SelectionMethod = Enums.SelectionMethod.LeastUtilization;
}
int i = 13;
for (; true; i++)
{
if (lines[i] == "")
{
break;
}
string[] line = lines[i].Split(',', ' ');
int t = int.Parse(line[0]);
decimal p = decimal.Parse(line[2]);
TimeDistribution tim = new TimeDistribution();
tim.Time = t;
tim.Probability = p;
sys.InterarrivalDistribution.Add(tim);
}
for (int j = i + 2, ii = 1; ii <= sys.NumberOfServers; ii++)
{
int a = j;
Server ser = new Server(ii);
for (int k = a; k < lines.Count() && lines[k] != ""; k++)
{
string[] line = lines[k].Split(new string[] { ", " }, StringSplitOptions.RemoveEmptyEntries);
int t = int.Parse(line[0]);
decimal p = decimal.Parse(line[1]);
TimeDistribution tim = new TimeDistribution();
tim.Time = t;
tim.Probability = p;
ser.TimeDistribution.Add(tim);
j++;
}
j += 2;
sys.Servers.Add(ser);
}
}
public void Intialize()
{
{
_simulationSystem.DowntimeCost = Convert.ToInt32(DownTime_txt.Text);
_simulationSystem.RepairPersonCost = Convert.ToInt32(RepairPersonCost_txt.Text);
_simulationSystem.BearingCost = Convert.ToInt32(NumBears_txt.Text);
_simulationSystem.NumberOfHours = Convert.ToInt32(NumHours_txt.Text);
_simulationSystem.NumberOfBearings = Convert.ToInt32(NumBears_txt.Text);
_simulationSystem.RepairTimeForOneBearing = Convert.ToInt32(RepairTime_txt.Text);
_simulationSystem.RepairTimeForAllBearings = Convert.ToInt32(RepairTimeAll_txt.Text);
}
decimal cumProb = 0;
foreach (DataGridViewRow row in BearingLife_DGV.Rows)
{
if (row.Cells[0].Value == null)
{
break;
}
TimeDistribution tmpTimeDistribution =
new TimeDistribution
{
Time = Convert.ToInt32(row.Cells[0].Value.ToString()),
Probability = Convert.ToDecimal(row.Cells[1].Value.ToString())
};
if (cumProb == 0)
{
tmpTimeDistribution.MinRange = 1;
}
else
{
tmpTimeDistribution.MinRange = Convert.ToInt32(cumProb * 100) + 1;
}
tmpTimeDistribution.CummProbability = cumProb + tmpTimeDistribution.Probability;
cumProb += tmpTimeDistribution.Probability;
tmpTimeDistribution.MaxRange = Convert.ToInt32(cumProb * 100);
_bearingDistributions.Add(tmpTimeDistribution);
}
cumProb = 0;
foreach (DataGridViewRow row in DelayTime_DGV.Rows)
{
if (row.Cells[0].Value == null)
{
break;
}
TimeDistribution tmpTimeDistribution =
new TimeDistribution
{
Time = Convert.ToInt32(row.Cells[0].Value.ToString()),
Probability = Convert.ToDecimal(row.Cells[1].Value.ToString())
};
if (cumProb == 0)
{
tmpTimeDistribution.MinRange = 1;
}
else
{
tmpTimeDistribution.MinRange = Convert.ToInt32(cumProb * 10) + 1;
}
tmpTimeDistribution.CummProbability = cumProb + tmpTimeDistribution.Probability;
cumProb += tmpTimeDistribution.Probability;
tmpTimeDistribution.MaxRange = Convert.ToInt32(cumProb * 10);
_delayDistributions.Add(tmpTimeDistribution);
}
}
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);
}
}
private void Form1_Load(object sender, EventArgs e)
{
simulationSystem = new SimulationSystem();
fileLines = new List <string>();
StreamReader sr = new StreamReader(@"D:\_FCIS\Sna 4\Semester 1\Modeling _ simulation\Simulation_Project\Task 1 - MultiQueueSimulation\MultiQueueSimulation\MultiQueueSimulation\TestCases\TestCase1.txt");
while (!sr.EndOfStream)
{
fileLines.Add(sr.ReadLine());
}
sr.Close();
///////////////////////////////////////////////////////
int idx_NumberOfServers = fileLines.IndexOf("NumberOfServers");
simulationSystem.NumberOfServers = Convert.ToInt32(fileLines[idx_NumberOfServers + 1]);
txtNumberOfServers.Text = simulationSystem.NumberOfServers.ToString();
int idx_StoppingNumber = fileLines.IndexOf("StoppingNumber");
simulationSystem.StoppingNumber = Convert.ToInt32(fileLines[idx_StoppingNumber + 1]);
txtStoppingNumber.Text = simulationSystem.StoppingNumber.ToString();
int idx_StoppingCriteria = fileLines.IndexOf("StoppingCriteria");
simulationSystem.StoppingCriteria = (Enums.StoppingCriteria)Convert.ToInt32(fileLines[idx_StoppingCriteria + 1]);
txtStoppingCriteria.Text = simulationSystem.StoppingCriteria.ToString();
int idx_SelectionMethod = fileLines.IndexOf("SelectionMethod");
simulationSystem.SelectionMethod = (Enums.SelectionMethod)Convert.ToInt32(fileLines[idx_SelectionMethod + 1]);
txtSelectionMethod.Text = simulationSystem.SelectionMethod.ToString();
///////////////////////////////////////////////////////
int idx_InterarrivalDistribution = fileLines.IndexOf("InterarrivalDistribution");
timeDistributions = new List <TimeDistribution>();
for (int i = idx_InterarrivalDistribution + 1; i < fileLines.Count(); ++i)
{
if (string.IsNullOrEmpty(fileLines[i]))
{
break;
}
timeDistribution = new TimeDistribution();
string[] numbers = fileLines[i].Split(new string[] { ", " }, StringSplitOptions.None);
timeDistribution.Time = Convert.ToInt32(numbers[0]);
timeDistribution.Probability = Convert.ToDecimal(numbers[1]);
timeDistributions.Add(timeDistribution);
}
simulationSystem.InterarrivalDistribution = timeDistributions;
simulationSystem.CalculateInterArrivalTimeDistribution();
dataGridViewInterarrival.DataSource = simulationSystem.InterarrivalDistribution;
///////////////////////////////////////////////////////
int idx_ServiceDistribution_Server = fileLines.IndexOf("ServiceDistribution_Server1") + 1, counter = 0;
for (int a = 0; a < simulationSystem.NumberOfServers; ++a)
{
timeDistributions = new List <TimeDistribution>();
idx_ServiceDistribution_Server += counter;
counter = 0;
for (int i = idx_ServiceDistribution_Server; i < fileLines.Count(); ++i)
{
if (string.IsNullOrEmpty(fileLines[i]))
{
counter += 2;
break;
}
counter++;
timeDistribution = new TimeDistribution();
string[] numbers = fileLines[i].Split(new string[] { ", " }, StringSplitOptions.None);
timeDistribution.Time = Convert.ToInt32(numbers[0]);
timeDistribution.Probability = Convert.ToDecimal(numbers[1]);
timeDistributions.Add(timeDistribution);
}
server = new Server();
server.ID = a + 1;
server.TimeDistribution = timeDistributions;
server.CalculateServiceTimeDistribution();
simulationSystem.Servers.Add(server);
}
txtServiceDistribution.Text = "Service Distribution (Server ID: " + simulationSystem.Servers[CounterOfServers].ID + ")";
dataGridViewServers.DataSource = simulationSystem.Servers[CounterOfServers].TimeDistribution;
}
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;
}
public void initialize_inputs()
{
sys.NumberOfServers = Convert.ToInt32(noOfServers_txt.Text);
sys.StoppingNumber = Convert.ToInt32(stoppingNo_txt.Text);
// map stopping criteria
List <KeyValuePair <string, int> > StoppingCriteriaList = GetEnumList <Enums.StoppingCriteria>();
int x = Convert.ToInt32(stoppingCriteria_txt.Text);
foreach (var val in StoppingCriteriaList)
{
if (val.Value == x)
{
sys.stoppingCase = val.Key;
break;
}
}
// map selection method
List <KeyValuePair <string, int> > SelectionMethodList = GetEnumList <Enums.SelectionMethod>();
int y = Convert.ToInt32(selectionMethod_txt.Text);
foreach (var val in SelectionMethodList)
{
if (val.Value == y)
{
sys.selectionMethod = val.Key;
break;
}
}
// servers data
Server server;
for (int i = 0; i < sys.NumberOfServers; i++)
{
server = new Server();
server.ID = i + 1;
sys.Servers.Add(server);
}
// service distribution
TimeDistribution serverTimeDist;
int count = serviceDist_grid.Rows.Count - 1;
for (int i = 0; i < count; i++)
{
serverTimeDist = new TimeDistribution();
serverTimeDist.Time = Convert.ToInt32(serviceDist_grid.Rows[i].Cells[1].Value);
serverTimeDist.Probability = Convert.ToDecimal(serviceDist_grid.Rows[i].Cells[2].Value);
int current = Convert.ToInt32(serviceDist_grid.Rows[i].Cells[0].Value.ToString());
sys.Servers[current - 1].TimeDistribution.Add(serverTimeDist);
}
// interarrival distribution
int numOfInterarrivals = interarrivalDist_grid.Rows.Count - 1;
TimeDistribution interarrivalDist;
for (int i = 0; i < numOfInterarrivals; i++)
{
interarrivalDist = new TimeDistribution();
interarrivalDist.Time = Convert.ToInt32(interarrivalDist_grid.Rows[i].Cells[0].Value.ToString());
interarrivalDist.Probability = Convert.ToDecimal(interarrivalDist_grid.Rows[i].Cells[1].Value.ToString());
sys.InterarrivalDistribution.Add(interarrivalDist);
}
sys.CalculateCummProbabilty();
}
