Assembly Line Balancing

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)