ABSTRACT
Reliability is one of the main parameters of the products
considered to be important to survive in the competitive market. Reliability in
its simple form means the probability that a failure may not occurs in a given
period of time i.e., the component performs adequately without failure. The
subsystems or components in a system are arranged in series or parallel depending
on the space constraint. However, the reliability of the system with components
arranged in parallel is more than that system for which the components are
arranged in series.
Redundancy is the method of arranging the components in a
subsystem in parallel such that if one component fails then the other component
automatically comes into operation. Through redundancy any desired level of
reliability can be obtained. But in doing so, we have to invest money or other
material resources to achieve the desired reliability. But a designer has to
consider the economic views of the organization in designing a system with high
reliability. Therefore, it is necessary to optimize the number of redundant
components in the system such that, though we cannot get the highest
reliability, we can have reliability to such a value that it can perform
adequately.
A stochastic redundancy problem is formulated and
simulation-programming technique is employed to arrive at the solution. Though
the component reliabilities at various stages of the system (input) is
estimated, stochastic reliabilities are assumed to nature of the components is
assumed as the circuit constants change due to active redundancy and component
follow stochastic distributions. A package in ‘C’ program for simulation
programming is developed.
INTRODUCTION
Redundancy is the provision of
alternative means or parallel paths in a system for accomplishing a given task
that all means must fail before causing the system failure. Application of
redundancy in the system design is found in almost all types of systems due to
numerous advantages over other methods of improving system reliability.
The important ones are: -
- Any desired level of reliability can be
achieved.
- Design through redundancy needs comparatively
less skill on the part of the designer.
- It provides quick solution.
- This method can be employed in the event of
failure of all other methods.
In design, construction and maintenance
of any engineering system, engineers have to take many technological and managerial
decisions at several stages. The ultimate goal of all such decisions is to either
minimize the effort required or to maximize the required benefit. In most of
the practical problems, decisions have to be made sequentially at different
points of time, at different points in space and at different levels. The
problems in which decisions are to be made sequentially are called sequential decision
problems. Since these decisions are to be made at a number of stages, they are
also referred to as multistage decision problems. Simulation programming is a
logical extension of mathematical techniques, well studied for the optimization
of multistage decision problems.
SIMULATION
“Simulation is a quantitative technique
developed for studying alternative courses of action by building a model of
that system and then conducting a series of repeated trial and error
experiments to predict the behaviour of the system over a period of time.”
In situations where the mathematical
formulation of the problem is not feasible, simulation technique is used by
representing reality through a model that will respond in the same manner as in
a real-life situation. In simulation, a certain type of mathematical model is
formulated which describes the real system’s operation. The system is divided
into various segments and their inter-relationships with some predictable
behaviour in terms of probability distributions for each of the possible stages
of the system are studied. The simulation experiment is then performed on the
model of the system.
The following are the reasons for
adopting simulation in place of other known mathematical techniques:
- It can handle complex systems that require the
modeling of interacting stochastic variants. These are the means for
modeling empirical or theoretical distribution of real-world parameters.
- Simulation may be the only method available
because it is difficult to observe the actual environment.
- Actual observations of a system may be too
expensive.
- There may not be sufficient time to allow the
system to operate extensively.
- Simulation enables one to study dynamically
systems either in real time, compressed time or expanded time.
- Simulation can be used to experiment with new
situations about which we have little or no information, so as to prepare
for what may happen.
- Simulation analysis can be performed to verify
analytical solutions.
- When new elements are introduced into a
system, simulation can be used to anticipate bottlenecks and other
problems that may arise in the behaviour of the system.
SOLUTION
THROUGH SIMULATION APPROACH
This process starts with assigning 1000
random numbers (0.000 to 0.999) to each of these probability distributions.
This is done in tabular column shown below. The cumulative probabilities and
range of random variables allotted can be calculated from the input data. We
can now conduct the simulation process to determine stage reliability of each
stage and in turn total system reliability. Generating a random number between
0.000 and 1.000 for each stage and allotting stage reliability by checking the
random number in the corresponding range of random numbers assigned does this
operation. Generation of random numbers is done through a probabilistic
mechanism. Most computer facilities include a generator of this kind in their software
libraries. If there is ‘n’ number of stages in the system, ‘n’ random numbers
are to be generated and stage reliability of stages R1, R2, R3, . . . . .. . .
Rn is calculated.
Now the system reliability is given as
Rsys =
1- product of unreliability’s of all stages
= 1- (1-R1`(1-R2)(1-R3)………..…(1-Rn).
This process is repeated for different
component combinations of the system. If there are ‘n’ stages and maximum of
‘m’ components in each stage, the total number of component combinations
achieved is mn.
So totally nx( mn )
random numbers are to be generated. The available cost condition is also taken into
consideration. The component combination of the system having highest
reliability, with in the range of available capital is considered as optimal
solution.
Since each simulation run is like a
single experiment conducted under a given set of conditions, conducting
simulation at once may not yield optimal solution. So for effectiveness the
process is repeated for number of times and the most frequently occurring
solution is taken as optimal solution.
C++ PROGRAM FOR SIMULATION
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
struct stage{
float r[10],p[10],c[10],g[10][2];
}s[10][10];
int
mstage,ncomp,i,j,k,u,cst=0,lc=0,yes=0;
int amstage[10][2],t;
int big;
int value[10];
int comb[500][10];
int totcost;
float rcomb[50][10];
int bestcomb[100][10];
float bestcombp[100];
void main(){
clrscr();
printf("\nEnter The Number Of
Stages :-");
scanf("%d",&mstage);
for(i=0;i<mstage;i++){
printf("\nEnter The Number Of
Components For Stage %d:",i+1);
scanf("%d",&ncomp);
amstage[i][1]=ncomp;
}
for(i=0;i<mstage;i++){
printf("\nEnter The Cost Of The
Stage %d:",i+1);
scanf("%d",&value[i]);}
int norp;
printf("\nEnter Total Available
Cost :");
scanf("%d",&totcost);
printf("\nEnter The Number Of
steps of Probability And Reliability Values:");
scanf("%d",&norp);
//input for reliability and probability
for(i=0;i<mstage;i++){
printf("\nStage :%d",i+1);
for(j=0;j<amstage[i][1];j++){
printf("\nComponent
:%d",j+1);
for(k=0;k<norp;k++){
printf("\nEnter Reliablility R %d
:",k+1);
scanf("%f",&s[i][j].r[k]);
printf("\nEnter Probability P
%d:",k+1);
scanf("%f",&s[i][j].p[k]);
}}}
for(;lc<100;lc++)
bestcomb[lc][mstage]=0;
lc=0;
for(;lc<100;lc++){
//for caluclating the cumulative
probability
for(i=0;i<mstage;i++)
for(j=0;j<amstage[i][1];j++)
for(k=0;k<norp;k++){
if(k==0)
s[i][j].c[k]=s[i][j].p[k];
else
s[i][j].c[k]=s[i][j].p[k]+s[i][j].c[k-1];
}
// for calculating the range
for(i=0;i<mstage;i++)
for(j=0;j<amstage[i][1];j++)
for(k=0;k<norp;k++){
if(k==0)
s[i][j].g[k][0]=0.00;
else
s[i][j].g[k][0]=s[i][j].c[k-1];
s[i][j].g[k][1]=s[i][j].c[k]-0.01;
}
// for generating the combintions
int r=0;
switch(mstage){
case 2:
for(i=1;i<=amstage[0][1];i++)
for(j=1;j<=amstage[1][1];j++){
comb[r][0]=i;
comb[r][1]=j;
r=r+1;
}break;
case 3:
for(i=1;i<=amstage[0][1];i++)
for(j=1;j<=amstage[1][1];j++)
for(k=1;k<=amstage[2][1];k++){
comb[r][0]=i;
comb[r][1]=j;
comb[r][2]=k;
r=r+1;
}break;
case 4:
for(i=1;i<=amstage[0][1];i++)
for(j=1;j<=amstage[1][1];j++)
for(k=1;k<=amstage[2][1];k++)
for(int m=1;m<=amstage[3][1];m++){
comb[r][0]=i;
comb[r][1]=j;
comb[r][2]=k;
comb[r][3]=m;
r=r+1;
}break;
case 5:
for(i=1;i<=amstage[0][1];i++)
for(j=1;j<=amstage[1][1];j++)
for(k=1;k<=amstage[2][1];k++)
for(int mf=1;mf<=amstage[3][1];mf++)
for(int mt=1;m<=amstage[4][1];mt++){
comb[r][0]=i;
comb[r][1]=j;
comb[r][2]=k;
comb[r][3]=mf;
comb[r][4]=mt;
r=r+1;
}
}
// for generating random numbers for
combinations
int l;
float ran;
for(l=0;l<r;l++)
for(i=0;i<mstage;i++){
ran=random(1000)/1000.0;
int stg;
for(j=0;j<ncomp;j++)
if(comb[l][i]==j+1){
stg=j;
break;
}
for(int o=0;o<norp;o++)
if((ran>=s[i][stg].g[o][0])&&(ran<=s[i][stg].g[o][1]))
rcomb[l][i]=s[i][stg].r[o];
}
// for calculating the cost
int cost[500];
for(i=0;i<r;i++){
cost[i]=0;
for(j=0;j<mstage;j++)
cost[i]+=comb[i][j]*value[j];
}
//for calculating the probabilites for
combinations
float pcomb[500],temp;
for(i=0;i<r;i++){
pcomb[i]=0;
temp=1;
for(j=0;j<mstage;j++)
temp*=(1.0-rcomb[i][j]);
pcomb[i]=1.0-temp;
}
//for selecting the best combination
float max=0;
for(i=0;i<r;i++)
if(pcomb[i]>max&&cost[i]<=totcost){
max=pcomb[i];
t=i;
}
if(lc==0){
int sg;
for(sg=0;sg<mstage;sg++)
bestcomb[lc][sg]=comb[t][sg];
bestcomb[lc][sg]=1;
bestcombp[lc]=pcomb[t];
}
else{
int ok=1,kg;
for(int vj=0;vj<lc;vj++){
for(kg=0;kg<mstage;kg++){
if(bestcomb[vj][kg]==comb[t][kg])
ok+=1;
}
if(ok==mstage){
bestcomb[vj][mstage]=(int)bestcomb[vj][mstage]+1;
if(pcomb[t]>bestcombp[vj])
bestcombp[vj]=pcomb[t];
break;
}
}
if(ok!=mstage){
for(int sg=0;sg<mstage;sg++)
bestcomb[lc][sg]=comb[t][sg];
bestcomb[lc][mstage]=1;
bestcombp[lc]=pcomb[t];
}
}
}
big=bestcomb[0][mstage];
int ct=0;
for(;ct<lc;ct++){
if(bestcomb[ct][mstage]>big)
big=bestcomb[ct][mstage];
}
int ftotal=0,sg;
int kt=0,tst;
for(;kt<=lc;kt++){
tst=(int)bestcomb[kt][mstage];
if(big==tst){
printf("\nOptimal Combination :\t
");
for(sg=0;sg<mstage;sg++)
printf("%d
",bestcomb[kt][sg]);
printf("\nCost : ");
for(sg=0;sg<mstage;sg++)
ftotal+=bestcomb[kt][sg]*value[sg];
printf("%d",ftotal);
printf("\nReliability:
%.3f",bestcombp[kt]);
break;
}}}
OUTPUT
Optimal combination : 2 3 1
Cost :10000
Reliability: 0.994
CONCLUSION
Simulation programming is successfully
applied to solve redundancy problems assuming component reliability a discrete
random variable. Assuming suitable continuous stochastic distribution for
component reliability at different stages, simulation programming can be
applied.
REFERENCES
1. Operations Research by G. V. Shenoy,
U. K. Srivastava, and S. C. Sharma.
2. Operations Research by Ravindran,
Phillips and Solberg.
3. Operations Research by C. K.
Mustafi.
EmoticonEmoticon