private static void RecieveData(Socket socket, List <CurrentSimulationCase> Table, PerformanceMeasures Performance)
{
byte[] buffer = new byte[1024];
int n = socket.Receive(buffer);
int len = int.Parse(Encoding.ASCII.GetString(buffer));
for (int i = 0; i < len; i++)
{
CurrentSimulationCase Case = new CurrentSimulationCase();
n = socket.Receive(buffer);
Case.Bearing.RandomHours = int.Parse(Encoding.ASCII.GetString(buffer));
n = socket.Receive(buffer);
Case.Bearing.Hours = int.Parse(Encoding.ASCII.GetString(buffer));
n = socket.Receive(buffer);
Case.RandomDelay = int.Parse(Encoding.ASCII.GetString(buffer));
n = socket.Receive(buffer);
Case.Delay = int.Parse(Encoding.ASCII.GetString(buffer));
n = socket.Receive(buffer);
Case.AccumulatedHours = int.Parse(Encoding.ASCII.GetString(buffer));
Table.Add(Case);
}
n = socket.Receive(buffer);
Performance.BearingCost = decimal.Parse(Encoding.ASCII.GetString(buffer));
n = socket.Receive(buffer);
Performance.DelayCost = decimal.Parse(Encoding.ASCII.GetString(buffer));
n = socket.Receive(buffer);
Performance.DowntimeCost = decimal.Parse(Encoding.ASCII.GetString(buffer));
n = socket.Receive(buffer);
Performance.RepairPersonCost = decimal.Parse(Encoding.ASCII.GetString(buffer));
n = socket.Receive(buffer);
Performance.TotalCost = decimal.Parse(Encoding.ASCII.GetString(buffer));
}
void BuildTable1()
{
int delayt = 0;
DataTable dc = new DataTable(), dc2 = new DataTable(), dc3 = new DataTable();
dc.Columns.Add("Bearing Index");
dc2.Columns.Add("Bearing rnd");
dc3.Columns.Add("bearing life");
Random rnd = new Random();
for (int bearingIDX = 1; bearingIDX <= simulationSystem.NumberOfBearings; bearingIDX++)
{
for (int life = 0; life < simulationSystem.NumberOfHours;)
{
CurrentSimulationCase csc = new CurrentSimulationCase();
csc.Bearing.Index = bearingIDX;
dc.Rows.Add(bearingIDX);
csc.Bearing.RandomHours = rnd.Next(1, 100);
dc2.Rows.Add(csc.Bearing.RandomHours);
csc.Bearing.Hours = binarySearch(csc.Bearing.RandomHours, simulationSystem.BearingLifeDistribution);
dc3.Rows.Add(csc.Bearing.Hours);
int lstIdx = simulationSystem.CurrentSimulationTable.Count;
csc.RandomDelay = rnd.Next(1, 100);
csc.AccumulatedHours = csc.Bearing.Hours + life;
csc.Delay = binarySearch(csc.RandomDelay, simulationSystem.DelayTimeDistribution);
simulationSystem.CurrentSimulationTable.Add(csc);
delayt += csc.Delay;
life = csc.AccumulatedHours;
}
}
simulationSystem.CurrentPerformanceMeasures.BearingCost = simulationSystem.CurrentSimulationTable.Count * simulationSystem.BearingCost;
simulationSystem.CurrentPerformanceMeasures.DelayCost = delayt * simulationSystem.DowntimeCost;
simulationSystem.CurrentPerformanceMeasures.DowntimeCost = simulationSystem.CurrentSimulationTable.Count * simulationSystem.RepairTimeForOneBearing * simulationSystem.DowntimeCost;
simulationSystem.CurrentPerformanceMeasures.RepairPersonCost = (decimal)simulationSystem.CurrentSimulationTable.Count * simulationSystem.RepairTimeForOneBearing * simulationSystem.RepairPersonCost / 60;
simulationSystem.CurrentPerformanceMeasures.TotalCost = simulationSystem.CurrentPerformanceMeasures.BearingCost + simulationSystem.CurrentPerformanceMeasures.DelayCost + simulationSystem.CurrentPerformanceMeasures.DowntimeCost + simulationSystem.CurrentPerformanceMeasures.RepairPersonCost;
dataGridView1.DataSource = simulationSystem.CurrentSimulationTable;
dataGridView1.Columns[0].Visible = false;
dataGridView1.Columns.Add("bearingIDX", "bearingIDX");
dataGridView1.Columns.Add("bearingRND", "bearingRND");
dataGridView1.Columns.Add("bearingLife", "bearingLife");
dataGridView1.Columns["bearingIDX"].DisplayIndex = 0;
dataGridView1.Columns["bearingRND"].DisplayIndex = 1;
dataGridView1.Columns["bearingLife"].DisplayIndex = 2;
for (int i = 0; i < simulationSystem.CurrentSimulationTable.Count; i++)
{
dataGridView1[dataGridView1.Columns.Count - 3, i].Value = Convert.ToInt32(dc.Rows[i][0]);
dataGridView1[dataGridView1.Columns.Count - 2, i].Value = Convert.ToInt32(dc2.Rows[i][0]);
dataGridView1[dataGridView1.Columns.Count - 1, i].Value = Convert.ToInt32(dc3.Rows[i][0]);
}
curBearing.Text = curBearing.Text + ": " + simulationSystem.CurrentPerformanceMeasures.BearingCost.ToString();
curCost.Text = curCost.Text + ": " + simulationSystem.CurrentPerformanceMeasures.TotalCost.ToString();
curDelay.Text = curDelay.Text + ": " + simulationSystem.CurrentPerformanceMeasures.DelayCost.ToString();
curDowntime.Text = curDowntime.Text + ": " + simulationSystem.CurrentPerformanceMeasures.DowntimeCost.ToString();
curRepair.Text = curRepair.Text + ": " + simulationSystem.CurrentPerformanceMeasures.RepairPersonCost.ToString();
}
private void Construst_concurrentPolicy()
{
List <CurrentSimulationCase> currentSimulationCases = new List <CurrentSimulationCase>();
PerformanceMeasures currentPerformanceMeasures = new PerformanceMeasures();
for (int i = 1; i <= _simulationSystem.NumberOfBearings; i++)
{
int accHours = 0;
while (true)
{
CurrentSimulationCase currentSimulation = new CurrentSimulationCase();
Bearing bearing = new Bearing();
bearing.Index = i;
bearing.RandomHours = _rnd.Next(1, 101);
bearing.Hours = Get_Hours(bearing.RandomHours);
currentSimulation.Bearing = bearing;
accHours += bearing.Hours;
currentSimulation.AccumulatedHours = accHours;
currentSimulation.RandomDelay = _rnd.Next(1, 11);
currentSimulation.Delay = Get_Delay(currentSimulation.RandomDelay);
currentSimulationCases.Add(currentSimulation);
if (currentSimulation.AccumulatedHours >= _simulationSystem.NumberOfHours)
{
break;
}
}
}
_simulationSystem.CurrentSimulationCases = currentSimulationCases;
currentPerformanceMeasures.BearingCost =
_simulationSystem.CurrentSimulationCases.Count * _simulationSystem.BearingCost;
currentPerformanceMeasures.DelayCost = Get_Delay_Accmulated() * _simulationSystem.DowntimeCost;
currentPerformanceMeasures.DowntimeCost =
_simulationSystem.CurrentSimulationCases.Count * _simulationSystem.RepairTimeForOneBearing *
_simulationSystem.DowntimeCost;
decimal val = Convert.ToDecimal(_simulationSystem.RepairPersonCost) / 60;
currentPerformanceMeasures.RepairPersonCost = _simulationSystem.CurrentSimulationCases.Count *
_simulationSystem.RepairTimeForOneBearing * val;
currentPerformanceMeasures.TotalCost = currentPerformanceMeasures.BearingCost +
currentPerformanceMeasures.DelayCost +
currentPerformanceMeasures.DowntimeCost +
currentPerformanceMeasures.RepairPersonCost;
_simulationSystem.CurrentPerformanceMeasures = currentPerformanceMeasures;
TotlBearingCost_lbl.Text = currentPerformanceMeasures.BearingCost.ToString(CultureInfo.CurrentCulture);
TotlCost_lbl.Text = currentPerformanceMeasures.TotalCost.ToString(CultureInfo.CurrentCulture);
TotlDelayCost_lbl.Text = currentPerformanceMeasures.DelayCost.ToString(CultureInfo.CurrentCulture);
TotlDownCost_lbl.Text = currentPerformanceMeasures.DowntimeCost.ToString(CultureInfo.CurrentCulture);
TotlRepairPerson_lbl.Text = currentPerformanceMeasures.RepairPersonCost.ToString(CultureInfo.CurrentCulture);
}
public void fillCurrentSimlationTable()
{
CurrentSimulationCase currentSimulation;
Random randomNum = new Random();
for (int j = 0; j < simSys.NumberOfBearings; j++)
{
int currentAccumelatedHours = 0;
int countBearings = 0;
while (true)
{
countBearings++;
Bearing bearing = new Bearing();
bearing.Index = j + 1;
//////////////////////////////////////////////Hours//////////////////////////////////////////////
currentSimulation = new CurrentSimulationCase();
bearing.RandomHours = randomNum.Next(1, 101);
for (int i = 0; i < simSys.BearingLifeDistribution.Count(); i++)
{
if (bearing.RandomHours >= simSys.BearingLifeDistribution[i].MinRange && bearing.RandomHours <= simSys.BearingLifeDistribution[i].MaxRange)
{
bearing.Hours = simSys.BearingLifeDistribution[i].Time;
break;
}
}
currentAccumelatedHours += bearing.Hours;
currentSimulation.Bearing = bearing;
currentSimulation.AccumulatedHours = currentAccumelatedHours;
/////////////////////////////////////////////////Delay/////////////////////////////////////////
currentSimulation.RandomDelay = randomNum.Next(1, 100);
for (int i = 0; i < simSys.DelayTimeDistribution.Count(); i++)
{
if (currentSimulation.RandomDelay >= simSys.DelayTimeDistribution[i].MinRange && currentSimulation.RandomDelay <= simSys.DelayTimeDistribution[i].MaxRange)
{
currentSimulation.Delay = simSys.DelayTimeDistribution[i].Time;
break;
}
}
totalDelay += currentSimulation.Delay;
simSys.CurrentSimulationTable.Add(currentSimulation);
if (currentAccumelatedHours >= simSys.NumberOfHours)
{
break;
}
}
countOfBearings.Add(countBearings);
}
}
public static void calculate_current_solution(DataGridView dataGridView3)
{
dataGridView3.Columns.Add("Count", "Count");
dataGridView3.Columns.Add("Index", "Index");
dataGridView3.Columns.Add("Random Life", "Random Life");
dataGridView3.Columns.Add("Life", "Life");
dataGridView3.Columns.Add("Accumelated Life", "Accumelated Life");
dataGridView3.Columns.Add("Random Delay", "Random Delay");
dataGridView3.Columns.Add("Delay", "Delay");
int Bearings_number = mysystem.NumberOfBearings;
int index_number = 1;
Random rand = new Random();
Random rand2 = new Random();
int counter = 0;
while (Bearings_number > 0)
{
bool bearing_start = true;
int round_cond = 0;
while (round_cond < mysystem.NumberOfHours)
{
CurrentSimulationCase temp = new CurrentSimulationCase();
temp.Bearing = new Bearing();
temp.Bearing.Index = index_number;
temp.Bearing.RandomHours = rand.Next(1, 100);
for (int i = 0; i < mysystem.BearingLifeDistribution.Count; i++)
{
if (temp.Bearing.RandomHours >= mysystem.BearingLifeDistribution[i].MinRange && temp.Bearing.RandomHours <= mysystem.BearingLifeDistribution[i].MaxRange)
{
temp.Bearing.Hours = mysystem.BearingLifeDistribution[i].Time;
}
}
if (bearing_start)
{
temp.AccumulatedHours = temp.Bearing.Hours;
bearing_start = false;
}
else
{
temp.AccumulatedHours = temp.Bearing.Hours + mysystem.CurrentSimulationCases[counter - 1].AccumulatedHours;
}
temp.RandomDelay = rand2.Next(1, 100);
for (int i = 0; i < mysystem.DelayTimeDistribution.Count; i++)
{
if (temp.RandomDelay >= mysystem.DelayTimeDistribution[i].MinRange && temp.RandomDelay <= mysystem.DelayTimeDistribution[i].MaxRange)
{
temp.Delay = mysystem.DelayTimeDistribution[i].Time;
}
}
round_cond = temp.AccumulatedHours;
mysystem.CurrentSimulationCases.Add(temp);
counter++;
}
index_number++;
bearing_start = true;
Bearings_number--;
}
int z, total_delay = 0;
for (z = 0; z < mysystem.CurrentSimulationCases.Count; z++)
{
dataGridView3.Rows.Add(z + 1, mysystem.CurrentSimulationCases[z].Bearing.Index, mysystem.CurrentSimulationCases[z].Bearing.RandomHours, mysystem.CurrentSimulationCases[z].Bearing.Hours, mysystem.CurrentSimulationCases[z].AccumulatedHours, mysystem.CurrentSimulationCases[z].RandomDelay, mysystem.CurrentSimulationCases[z].Delay);
total_delay += mysystem.CurrentSimulationCases[z].Delay;
}
decimal total = decimal.Parse(z.ToString());
mysystem.CurrentPerformanceMeasures.BearingCost = total * mysystem.BearingCost;
mysystem.CurrentPerformanceMeasures.DelayCost = total_delay * mysystem.DowntimeCost;
mysystem.CurrentPerformanceMeasures.DowntimeCost = total * mysystem.RepairTimeForOneBearing * mysystem.DowntimeCost;
mysystem.CurrentPerformanceMeasures.RepairPersonCost = total * mysystem.RepairTimeForOneBearing * mysystem.RepairPersonCost / 60;
mysystem.CurrentPerformanceMeasures.TotalCost = mysystem.CurrentPerformanceMeasures.BearingCost + mysystem.CurrentPerformanceMeasures.DelayCost + mysystem.CurrentPerformanceMeasures.DowntimeCost + mysystem.CurrentPerformanceMeasures.RepairPersonCost;
}
