This action might not be possible to undo. Are you sure you want to continue?
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
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
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. 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. 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, 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 (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 (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.
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.
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, W 2, W 3, …... ,W N ] Where, W i represents the last process contained in workstation i. Therefore, the ith workstation will contain the processes form W i-1 +1 to W i 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.
INPUT: List = [1 2 3 4 5 6] Ct = 6 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. *six processes with process times in ascending order *desired cycle time
The following is another example of the same algorithm application: INPUT: List = [111 162 173 168 97 130 Ct= 300 OUTPUT: WS= [2 3
66 70 151 124
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.
INPUT: List = [ 1 2 3 4 5 6 ] Ct = 6 *six processes with process times in ascending order *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.
INPUT: List = [111 162 173 168 97 130 Ct= 300 63 66 70 151 124 78 124 72 58]
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.:
Simple Method, Smoothness Index = 16.2481 Reverse Method, Smoothness Index = 19.5704 Perturbation Method, Smoothness Index = 16.2481
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 Ct= 900
253 240 211 301 384 240 243 106
60 180 192 344]
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 (WS)2=[1 (WS)3=[3
6 4 6
8 13 15] 7 10 15] 8 12 15]
(WT)1=[702 704 685 829 536] (WT)2=[318 637 752 867 882] (WT)3=[702 704 685 649 716] (SI)1=26.2488 (SI)2=30.8869 (SI)3=11.1355
WT: Workstation Time
SI: Smoothness Index
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.
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.
1. Project and Production Management, NPTEL Video Lecture by Prof Arun Kanda, Indian Institute of Technology.
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
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)
This action might not be possible to undo. Are you sure you want to continue?
We've moved you to where you read on your other device.
Get the full title to continue listening from where you left off, or restart the preview.