public PerformanceMeasures SolveCurrentSimulationCase()
{
decimal bearingReplacementCost = 0;
decimal costOfDelayTime = 0;
decimal costOfDownTime = 0;
decimal costOfRepairPerson = 0;
for (int i = 0; i < NumberOfBearings; i++)
{
List <CurrentSimulationCase> thisCase = CurrentSimulationTable.FindAll(listElement => listElement.Bearing.Index == i);
bearingReplacementCost += thisCase.Count * BearingCost;
costOfDownTime += thisCase.Count * RepairTimeForOneBearing * DowntimeCost;
int totalDelayTime = thisCase.Sum(listElement => listElement.Delay);
costOfDelayTime += totalDelayTime * DowntimeCost;
costOfRepairPerson += RepairTimeForOneBearing * thisCase.Count * RepairPersonCost / Hour;
}
PerformanceMeasures ret = new PerformanceMeasures
{
BearingCost = bearingReplacementCost,
DelayCost = costOfDelayTime,
DowntimeCost = costOfDownTime,
RepairPersonCost = costOfRepairPerson
};
ret.TotalCost = ret.BearingCost + ret.DelayCost + ret.DowntimeCost + ret.RepairPersonCost;
return(ret);
}
public void calc_bearing()
{
Random rand = new Random();
int index = 0;
int j;
for (int i = 1; i <= NumberOfBearings; i++)
{
j = 0;
while (true)
{
CurrentSimulationCase Current_case = new CurrentSimulationCase();
Current_case.Bearing.Index = i;
int ran_hours = rand.Next(1, 101);
Current_case.Bearing.RandomHours = ran_hours;
for (int k = 0; k < BearingLifeDistribution.Count; k++)
{
if (ran_hours <= BearingLifeDistribution[k].MaxRange && ran_hours >= BearingLifeDistribution[k].MinRange)
{
Current_case.Bearing.Hours = BearingLifeDistribution[k].Time;
break;
}
}
if (j == 0)
{
Current_case.AccumulatedHours = Current_case.Bearing.Hours;
}
else
{
Current_case.AccumulatedHours = Current_case.Bearing.Hours + CurrentSimulationTable[index - 1].AccumulatedHours;
}
int ran_delay = rand.Next(1, 101);
Current_case.RandomDelay = ran_delay;
for (int k = 0; k < DelayTimeDistribution.Count; k++)
{
if (ran_delay <= DelayTimeDistribution[k].MaxRange && ran_delay >= DelayTimeDistribution[k].MinRange)
{
Current_case.Delay = DelayTimeDistribution[k].Time;
break;
}
}
CurrentSimulationTable.Add(Current_case);
index++;
if (Current_case.AccumulatedHours >= NumberOfHours)
{
break;
}
else
{
j++;
}
}
}
}
public void currentMethodPerformance()
{
int numOfBearings = CurrentSimulationTable.Count();
CurrentPerformanceMeasures.CalculateBearingCost(numOfBearings, BearingCost);
CurrentPerformanceMeasures.CalculateDelayCost(totalCurrentDelayTime, DowntimeCost);
CurrentPerformanceMeasures.CalculateDowntimeCost(numOfBearings, RepairTimeForOneBearing, DowntimeCost);
CurrentPerformanceMeasures.CalculateRepairPersonCost(numOfBearings, RepairTimeForOneBearing, RepairPersonCost);
CurrentPerformanceMeasures.CalculateTotalCost();
}
public void fillSimulationTableForCurrent()
{
int SumOfDelayTime = 0;
Sets = new List <int>();
AccumulatedSetsNumbers = new List <int>();
AccumulatedSetsNumbers.Add(0);
//Console.WriteLine(AccumulatedSetsNumbers.Count.ToString());
AccumulatedSetsNumbers[0] = 0;
Random rand = new Random();
CurrentSimulationCase row = new CurrentSimulationCase();
for (int i = 0; i < NumberOfBearings; i++)
{
int cnt = 1;
row = new CurrentSimulationCase();
row.Bearing.Index = i + 1;
row.Bearing.RandomHours = rand.Next(1, 100);
row.Bearing.Hours = SearchForHours(row.Bearing.RandomHours, BearingLifeDistribution);
row.AccumulatedHours = row.Bearing.Hours;
row.RandomDelay = rand.Next(1, 100);
row.Delay = SearchForHours(row.RandomDelay, DelayTimeDistribution);
CurrentSimulationTable.Add(row);
SumOfDelayTime += row.Delay;
while (true)
{
if (row.AccumulatedHours >= NumberOfHours)
{
break;
}
row = new CurrentSimulationCase();
row.Bearing.Index = i + 1;
row.Bearing.RandomHours = rand.Next(1, 100);
row.Bearing.Hours = SearchForHours(row.Bearing.RandomHours, BearingLifeDistribution);
row.AccumulatedHours = row.Bearing.Hours + CurrentSimulationTable[CurrentSimulationTable.Count - 1].AccumulatedHours;
row.RandomDelay = rand.Next(1, 100);
row.Delay = SearchForHours(row.RandomDelay, DelayTimeDistribution);
CurrentSimulationTable.Add(row);
SumOfDelayTime += row.Delay;
cnt++;
}
MaxNumOfSets = Math.Max(MaxNumOfSets, cnt);
Sets.Add(cnt);
AccumulatedSetsNumbers.Add(AccumulatedSetsNumbers[i] + Sets[i]);
}
CurrentPerformanceMeasures.BearingCost = Convert.ToDecimal(CurrentSimulationTable.Count) * Convert.ToDecimal(BearingCost);
CurrentPerformanceMeasures.DelayCost = Convert.ToDecimal(SumOfDelayTime) * Convert.ToDecimal(DowntimeCost);
CurrentPerformanceMeasures.DowntimeCost = Convert.ToDecimal(CurrentSimulationTable.Count) * Convert.ToDecimal(RepairTimeForOneBearing) * Convert.ToDecimal(DowntimeCost);
CurrentPerformanceMeasures.RepairPersonCost = Convert.ToDecimal(CurrentSimulationTable.Count) * Convert.ToDecimal(RepairTimeForOneBearing) * Convert.ToDecimal(RepairPersonCost) / Convert.ToDecimal(60);
CurrentPerformanceMeasures.TotalCost = CurrentPerformanceMeasures.BearingCost + CurrentPerformanceMeasures.DelayCost + CurrentPerformanceMeasures.DowntimeCost + CurrentPerformanceMeasures.RepairPersonCost;
}
private int replaceOneBearing(int index, int i, int b)
{
CurrentSimulationCase currentSimulationCase = new CurrentSimulationCase();
currentSimulationCase.Bearing = getBearing(index, i);
b += currentSimulationCase.Bearing.Hours;
currentSimulationCase.AccumulatedHours = b;
currentSimulationCase.RandomDelay = r.Next(1, 101);//#TODO it should be 0 , 9 ??
currentSimulationCase.Delay = getDelay(currentSimulationCase.RandomDelay);
CurrentSimulationTable.Add(currentSimulationCase);
return(b);
}
public void simulate()
{
Random rnd = new Random();
List <Bearing> [] my_bears = new List <Bearing> [NumberOfBearings];
for (int i = 0; i < NumberOfBearings; i++)
{
int accum = 0;
my_bears[i] = new List <Bearing>();
while (accum < NumberOfHours)
{
CurrentSimulationCase curbear = new CurrentSimulationCase();
curbear.Bearing.Index = i + 1;
curbear.Bearing.RandomHours = rnd.Next(1, 100);
curbear.Bearing.Hours = life_dist(curbear.Bearing.RandomHours);
accum = accum + curbear.Bearing.Hours;
curbear.AccumulatedHours = accum;
curbear.RandomDelay = rnd.Next(1, 100);
curbear.Delay = delay_dist(curbear.RandomDelay);
CurrentPerformanceMeasures.DelayCost += (decimal)curbear.Delay * DowntimeCost;
my_bears[i].Add(curbear.Bearing);
CurrentSimulationTable.Add(curbear);
}
}
CurrentPerformanceMeasures.BearingCost = (decimal)CurrentSimulationTable.Count * BearingCost;
CurrentPerformanceMeasures.DowntimeCost = (decimal)CurrentSimulationTable.Count * RepairTimeForOneBearing * DowntimeCost;
decimal nrcost = (decimal)RepairPersonCost / 60;
CurrentPerformanceMeasures.RepairPersonCost = (decimal)(CurrentSimulationTable.Count * RepairTimeForOneBearing) * nrcost;
CurrentPerformanceMeasures.TotalCost = (decimal)CurrentPerformanceMeasures.BearingCost + CurrentPerformanceMeasures.DelayCost
+ CurrentPerformanceMeasures.DowntimeCost + CurrentPerformanceMeasures.RepairPersonCost;
sec_step(my_bears);
}
public void CurrentSimulation()
{
totalCurrentDelayTime = 0;
int accumulatedHours;
for (int i = 0; i < NumberOfBearings; i++)
{
accumulatedHours = 0;
for (int j = 0; j < bearings[i].Count(); j++)
{
CurrentSimulationCase currentCase = new CurrentSimulationCase();
currentCase.Bearing.Hours = bearings[i][j].Hours;
currentCase.Bearing.RandomHours = bearings[i][j].RandomHours;
currentCase.Bearing.Index = bearings[i][j].Index;
accumulatedHours += currentCase.Bearing.Hours;
currentCase.AccumulatedHours = accumulatedHours;
Tuple <int, int> delay = HelperFunctions.GetBearingRandomNumbers("Delay", DelayTimeDistribution);
currentCase.RandomDelay = delay.Item1;
currentCase.Delay = delay.Item2;
CurrentSimulationTable.Add(currentCase);
totalCurrentDelayTime += currentCase.Delay;
}
}
}
public void SetValues()
{
Random rd = new Random();
Random rd1 = new Random();
int i = 0;
bool contt = true;
bool accumelator_zero = true;
for (int s = 1; s <= NumberOfBearings; s++)
{
contt = true;
accumelator_zero = true;
while (contt == true)
{
CurrentSimulationTable.Add(new CurrentSimulationCase());
CurrentSimulationTable[i].Bearing = new Bearing();
CurrentSimulationTable[i].Bearing.RandomHours = rd.Next(1, 100); //1_c
CurrentSimulationTable[i].Bearing.Index = s;
for (int k = 0; k < BearingLifeDistribution.Count; k++) //2_c
{
if (CurrentSimulationTable[i].Bearing.RandomHours >= BearingLifeDistribution[k].MinRange &&
CurrentSimulationTable[i].Bearing.RandomHours <= BearingLifeDistribution[k].MaxRange)
{
CurrentSimulationTable[i].Bearing.Hours = BearingLifeDistribution[k].Time;
break;
}
}
if (accumelator_zero == true)
{
CurrentSimulationTable[i].AccumulatedHours = CurrentSimulationTable[i].Bearing.Hours;//3_c
accumelator_zero = false;
}
else
{
CurrentSimulationTable[i].AccumulatedHours = CurrentSimulationTable[i - 1].AccumulatedHours + CurrentSimulationTable[i].Bearing.Hours;//3_c
}
CurrentSimulationTable[i].RandomDelay = rd1.Next(1, 100); //4_c
for (int k = 0; k < DelayTimeDistribution.Count; k++) //5_c
{
if (CurrentSimulationTable[i].RandomDelay >= DelayTimeDistribution[k].MinRange &&
CurrentSimulationTable[i].RandomDelay <= DelayTimeDistribution[k].MaxRange)
{
CurrentSimulationTable[i].Delay = DelayTimeDistribution[k].Time;
TotalDelayTime += CurrentSimulationTable[i].Delay;
break;
}
}
if (CurrentSimulationTable[i].AccumulatedHours >= NumberOfHours)
{
contt = false;
accumelator_zero = true;
}
i++;
}
}
//NumberOfBearChanged = i;
}
