Date post: | 29-Oct-2014 |
Category: |
Documents |
Upload: | abhishek-ghosh |
View: | 200 times |
Download: | 4 times |
MEL 425 Optimization
Term Project Report
Assembly Line Balancing
Submitted by
Jyotiraj Thakuria (P2009ME1025)
Abhishek Ghosh (P2009ME1074)
Under the Guidance of
Dr. Ekta Singla
School of Mechanical, Material and Energy Engineering
Indian Institute of Technology Ropar
Abstract
Assembly lines are flow-line production systems which are of great importance in the industrial
production of high volume standardized commodities and more recently even gained
importance in low volume production of customized products. Due to high capital requirements
when installing or redesigning a line, configuration planning is of great relevance for
practitioners.
In the present problem a manufacturing unit needs to be set up for the processing of a
particular product. The product needs to go through a number of operations from its starting to
end phase before completion. These operations need to be performed consecutively in the
given order. Each process has an associated cycle time ( the time needed for processing a
single work unit ).This is a simplification of the actual industry problems where some of the
processes could be running in parallel. Further, it has been assumed that these processes
have to be performed in an assembly line manufacturing plant in a given cycle time (Constraint).
The problem lies in combining the processes into independent workstations such that the given
cycle time is achieved with the maximum line efficiency possible. Algorithms have been devised
to solve this problem. Also, within the possible setups which have the same line efficiency, the
setup with the maximum smoothness is chosen.
Thus the solution algorithm provides with the desired number of workstations to be set up (N)
with the details of processes pertaining to each workstation.
Table of Contents
Abstract
Table of Contents
Introduction
The Line Balancing Problem
Terminology for Line Balancing
Minimum Rational Work Element
Total Work Content
Cycle Time
Line Efficiency
Balance Delay (Balancing Loss)
Smoothness Index
Example of line balancing
Problem Definition
Given
Problem
Solution Algorithms Devised
1. Simple Method
Example 1.1
Example 1.2
2. Reverse Method
Example 2.1
Example 2.2
3. Smoothness index optimization [ Perturbation Method ]
Example 3.1
Analysis
Conclusion
References
MATLAB Code
Function files
Script file
Introduction
An assembly line is a flow-oriented production system where the productive units performing the
operations, referred to as stations, are aligned in a serial manner. The workpieces visit stations
successively as they are moved along the line usually by some kind of transportation system,
e.g. a conveyor belt.
Originally, assembly lines were developed for a cost efficient mass production of standardized
products, designed to exploit a high specialization of labour and the associated learning effects
(Shtub and Dar-El, 1989; Scholl, 1999, p. 2). Since the times of Henry Ford, product
requirements and thereby the requirements of production systems have changed dramatically.
In order to respond to diversified customer needs, companies have to allow for an
individualization of their products. For example, the German car manufacturer BMW offers a
catalogue of optional features which, theoretically, results in 1032 different models (Meyr, 2004).
Multipurpose machines with automated tool swaps allow for a facultative production sequence
of varying models at negligible setup times and costs. This makes efficient flow-line systems
available for low volume assembly-to-order production (Mather, 1989) and enables modern
production strategies like mass customization (Pine, 1993). This in turn ensures that the
thorough planning and implementation of assembly systems will remain of high practical
relevance in the foreseeable future.
The Line Balancing Problem
1 The line balancing problem is to arrange the individual processing and assembly tasks at
the workstations so that the total time required at each workstation is approximately the
same.
2 If the work elements can be grouped so that all the station times are exactly equal, we
have perfect balance on the line and we can expect the production to flow smoothly.
3 In most practical situations it is very difficult to achieve perfect balance. When
workstation times are unequal, the slowest station determines the overall production rate
of the line.
Terminology for Line Balancing
Minimum Rational Work Element
Minimum rational work element is the smallest practical indivisible tasks into which the job can
be divided. These work elements cannot be subdivided further.
Example: drilling a hole, screw and nut etc.
Tej: where j is used to identify the element out of the n elements that make up the total work.
Total Work Content
Total work, Twc, content is the aggregate of all the work elements to be done on the line.
Cycle Time
Cycle time, Tc, is the ideal or theoretical cycle time of the flow line, which is the time interval
between parts coming off the line. When consider efficiency, E, the ideal cycle time must be
reduce
Where RP is the production rate
● At efficiencies less than 100% the ideal cycle time must be reduced (or ideal production
rate must be increased).
● The minimum possible value of Tc is established by the bottleneck station, the one with
the largest value of Ts.
Line Efficiency
Line efficiency (LE) shows the percentage utilization of the line. It is expressed as the ratio of
the total station time to the cycle time multiplied by the number of workstations.
Balance Delay (Balancing Loss)
Balance delay is a measure of the line inefficiency which results from idle time due to imperfect
allocation of work among station.
Smoothness Index
Smoothness index (SI) describes relative smoothness for a given assembly line balance. It
calculates the idle time of a workstation. Perfect balance is indicated by smoothness index value
of 0. This is calculated as follows.
Example of line balancing
The graph below showing the number of processes required to accomplish an assembly
operation with the number inside the circle showing element number. The value just above the
jth circle indicates the time required for the jth process.
Cycle time (10 units) depending on the demand rate of the product.
Set of processes are clubbed together in a single workstation such that the station time of each
workstation is less than or equal to the cycle time. Line efficiency and Smoothness index are
calculated based on the data.
Problem Definition
Given
A manufacturing unit needs to be set up for the processing of a particular product. The product
needs to go through M number of operations from its starting to end phase before completion.
These operations need to be performed consecutively in the given order, which in the present
case is: 1, 2, 3,..., M. Each process has an associated cycle time ( the time needed for
processing a single work unit ), represented as a list. Hence
List = [T1, T2, T3, …,TM ]
Where, Ti represents the processing time of the ith operation.
This is a simplification of the actual industry problems where some of the processes can be
performed in parallel too.
Problem
These processes have to be performed in an assembly line manufacturing plant in a given cycle
time (Ct).
The problem lies in combining the processes into independent workstations such that the given
cycle time is achieved with the maximum line efficiency possible.
Thus the desired output from the solution algorithm is to provide the desired number of
workstations to be set up (N) with the details of processes pertaining to each workstation.
Hence the output array is of the form:
WS = [W1, W2, W3, …... ,WN ]
Where, Wi represents the last process contained in workstation i.
Therefore, the ith workstation will contain the processes form Wi-1 +1 to Wi as ordered in the
input process time list.
Solution Algorithms Devised
Given a problem of this kind, two parameters are essential to check for the requirement of a
solution, namely
1 The bottleneck process i.e. the time duration corresponding to the most time taking
process.
No matter how we arrange the workstations, if the cycle time required is lower than this
limit; the problem can’t be solved with a single assembly line. In that case, multiple
assembly lines are required to run in parallel.
2. The sum of all the process times.
This is the theoretical upper limit to the maximum time taken by any assembly line. It is
the case when all the operations take place sequentially in a single workstation.
From this discussion, it is clear that for the algorithm to provide a solution, the required cycle
time which is the problem constraint should lie between these limits.
1. Simple Method
In this method, starting from the first process we group them together till they do not exceed the
cycle time limit, after which we make a new workstation group. Thus in this way all the
workstations are formed. The resulting cycle time will be lower than the objective cycle time.
Example 1.1
INPUT:
List = [1 2 3 4 5 6] *six processes with process times in ascending order
Ct = 6 *desired cycle time
OUTPUT:
WS = [3 4 5 6]
This result implies that there will be four workstations where the first station contains the first
three processes, the second one contains the fourth process, third one the fifth process and the
last station consists of the sixth process respectively.
Example 1.2
The following is another example of the same algorithm application:
INPUT:
List = [111 162 173 168 97 130 63 66 70 151 124 78 124 72 58]
Ct= 300
OUTPUT:
WS= [2 3 5 8 10 12 15]
The processing time of individual workstations is given by:
Work Time = [273 173 265 259 221 202 254]
2. Reverse Method
This method is similar to the previous method with the process list flipped. The solution obtained
is then further flipped appropriately to present the final solution.
Example 2.1
INPUT:
List = [ 1 2 3 4 5 6 ] *six processes with process times in ascending order
Ct = 6 *desired cycle time
OUTPUT:
WS = [3 4 5 6]
This result is similar to that of Example 1.1. However it is not always the case as seen in
Example 2.2.
Example 2.2
INPUT:
List = [111 162 173 168 97 130 63 66 70 151 124 78 124 72 58]
Ct= 300
OUTPUT:
WS = [2 3 4 7 10 12 15]
Work Time = [273 173 168 290 287 202 254]
Compared to the solution obtained in Example 1.2, the results have changed.
3. Smoothness index optimization (Perturbation Method)
Through this algorithm, the assembly line setup with the minimum smoothness index is
determined. The algorithm works by perturbing the initial solution obtained by the simple method
and moving in a direction which reduces the smoothness of the line. In this way final
convergence is reached.
In the following example the Smoothness Index values for the three methods has been
compared for the list value of Example 1.2.:
Example 3.1
Simple Method, Smoothness Index = 16.2481
Reverse Method, Smoothness Index = 19.5704
Perturbation Method, Smoothness Index = 16.2481
Analysis
Once the algorithms were devised and tested, we implemented these algorithms by using
randomly generate numbers for the test process time.
Hence the list we used consists of randomly generated integer values within some processing
time range:
List = fix (lower + (upper-lower)*rand (n, 1))
Where,
List : the test process time list
Lower : lower time limit on the processes
n : number of processes
Next, a suitable input list was selected from several test runs which shows the characteristics of
all the three algorithms. An appropriate cycle time (Ct) was also selected.
INPUT
List = [318 200 184 253 240 211 301 384 240 243 106 60 180 192 344]
Ct= 900
This input list was then processed through all the three algorithms to find out the WS,
work time and smoothness respectively.
OUTPUT
(WS)1=[ 3 6 8 13 15] WS: Workstation
(WS)2=[1 4 7 10 15]
(WS)3=[3 6 8 12 15]
(WT)1=[702 704 685 829 536] WT: Workstation Time
(WT)2=[318 637 752 867 882]
(WT)3=[702 704 685 649 716]
(SI)1=26.2488 SI: Smoothness Index
(SI)2=30.8869
(SI)3=11.1355
Where 1: Simple Method
2: Reverse Method
3: Smoothness index optimization Method
Throughout the different algorithms, the line efficiency hasn’t changed and remains fixed at 76.8
%. However, as expected the smoothness index decreases for the third algorithm.
Conclusion
In this project, we tried to increase the line efficiency of an assembly operation. But, even by the
host of developed algorithms, line efficiency remains same for all the cases. Various algorithms
produce different setups for workstations but all having the same line efficiency.
However the smoothness index changes substantially both after the reverse method and
smoothness index optimization algorithm. The optimal design comes from the third algorithm.
References
1. Project and Production Management, NPTEL Video Lecture by Prof Arun Kanda,
Indian Institute of Technology.
MATLAB Code
Function files
generate < generates the random list for input as test input >
function ST = generate (st,fn,n)
ST=fix(st + (fn-st)*rand(n,1));
end
sim_bal < performs the simple method algorithm on a list >
function A=sim_bal(list,ct)
m=length(list);
low=min(list);
high=sum(list);
j=0;
s=0;
i=1;
if ct < low
disp('Parallel assembly lines needed. Bottleneck operation exceeds the given cycle time');
elseif ct > high
disp('Assembly line not required');
else
while i<=m
while i<=m && (s+list(i)) <= ct
s=s+list(i);
i=i+1;
end
j=j+1;
s=0;
A(j)=i-1;
end
end
end
worktime < computes the work time of individual workstations in form of an array >
function W= worktime(list,A)
n=length(A);
s=0;
for t=1:A(1)
s=s+list(t);
end
W(1)=s;
s=0;
for i=2:n
x=A(i-1);
y=A(i);
for t= x+1:y
s=s+list(t);
end
W(i)=s;
s=0;
end
end
le < computes the line efficiency of the assembly line >
function A=le(list,ct,n)
b=sum(list);
c=n*ct;
A=(b/c);
end
si < computes the smoothness index of the assembly line >
function S=si(list,A)
w=worktime(list,A);
c=max(w);
S=sqrt(sum(c-w));
end
rev_bal < performs the reverse method algorithm on a list >
function A=rev_bal(list1,ct)
list=list1(end:-1:1);
m=length(list);
low=min(list);
high=sum(list);
j=0;
s=0;
i=1;
if ct < low
disp('Parallel assembly lines needed. Bottleneck operation exceeds the given cycle time');
elseif ct > high
disp('Assembly line not required');
else
while i<=m
while i<=m && (s+list(i)) <= ct
s=s+list(i);
i=i+1;
end
j=j+1;
s=0;
B(j)=i-1;
end
end
C=B(end:-1:1);
for x=2:j
A(x-1)=C(1)-C(x);
end
A(j)=m;
end
boxsi < performs the smoothness index optimization on a list >
function T = boxsi(list, ct)
low=min(list);
high=sum(list);
O=sim_bal(list,ct);
times =O;
sibest= si(list,O);
for i= 1:length(O)-1
curr = list(O(i):O(length(O)));
B= sim_bali(curr,ct);
W = si(list,[ O(1:i-1), O(i)-1,O(i)-1+B]);
if W < sibest
sibest =W;
times= [ O(1:i-1), O(i)-1,O(i)-1+B];
O= times;
end
end
T=times;
end
sim_bali
function A=sim_bali(list,ct)
m=length(list);
low=min(list);
high=sum(list);
j=0;
s=0;
i=1;
while i<=m
while i<=m && (s+list(i)) <= ct
s=s+list(i);
i=i+1;
end
j=j+1;
s=0;
A(j)=i-1;
end
end
Script file
s=generate(50,400,100)
ct=5000;
A=sim_bal(s,ct)
rev_bal(s,ct)
worktime(s,A)
si(s,A)
EX=box(s,ct)
new=boxsi(s,ct)