Aðgerðagreining
Assembly Line Balancing
10.04.2011
Efnisyrlit
1
Title
2
2
executive summary
2
2.1
2
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
Findings, conclusion and recommendations
3
4
Methods
4
4.1
Theory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
4.2
Technology
6
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
references
7
6
Appendix
7
6.1
Mathematical models . . . . . . . . . . . . . . . . . . . . . . . . .
9
6.2
Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
1
Aðgerðagreining(IÐN401G)
Reikniverkefni 2
Assembly Line Balancing
Axel Viðarsson
Ágúst Þorri Tryggvason
Davíð Freyr Hlynsson
10.04.2011
Aðgerðagreining
Assembly Line Balancing
10.04.2011
1 Title
2 executive summary
This paper investigates a Simple assembly line balancing problem (SALBP). The
rst subcategories of SALBP is tybe 1 and its objective function is to minimize
the number of workstations, but in this paper we will concentrate on type 2 and
its objective function is to minimize the desired cycle time.
2.1
An
Introduction
assembly line
is a manufacturing process in which two or more separate tasks
are tted together in a sequential manner to form a new product, and nally
resulting in the nished product. The tasks are generally interchangeable, so
an optimal schedule for in which order they should be processed is needed to
create the nished product as soon as possible, in Operations Management this
is referred to as
assembly line balancing problem
(ALBP)[1].
Henry Ford and Ransom E. Olds are credited with the invention of the assembly
line, although (as is the case with many inventions) the assembly line's development included many inventors. It combined the idea of interchangeable parts
(another gradual technological development that is often mistakenly attributed
to one individual or another). After 5 years of empirical development, Ford's
rst moving assembly line (employing conveyor belts) began mass production
on or around April 1, 1913. The concept was rst applied to subassemblies, and
shortly after to the entire chassis. Although it is inaccurate to say that Ford personally invented the assembly line, his sponsorship of its development and use
was central to its explosive success in the 20th century. In large factories, which
are based on many dierent workstations with dierent production time, Such
as the Ford factory is, there are often optimization problems to be resolved.
One of the most common Things That factories want is to nish its product
in Shorter amount of time or rear They range workstations.
Those kind of
problems are called assembly line Balancing Problem (ALBP).
In an Assembly Line Balancing Problem (ALBP) a set of tasks have to be
assigned to an ordered sequence of workstations in such a way that precedence
constraints are maintained and a given eciency measure is optimized, such
as, for example, the number of workstations or the workstation time (i.e. the
cycle time). In the simplest case, referred to in the literature as SALBP: Simple
Assembly Line Balancing Problem, a serial line processes a single model of one
product. Basically, the problem is restricted by technological precedence relations and the cycle time constrains.[2]
A classication proposed by Baybars (1986) divides all balancing problems into
two classes: a rst class of problems known as simple, SALBP , whose members
are clearly stated in the aforementioned work, and a second class of problems
known as generals, GALBP, which is constituted of all other problems not
belonging to the SALBP class.
The SALBP class is constituted of assembly
problems where only two kinds of task assignment constraints are taken into
2
Aðgerðagreining
Assembly Line Balancing
10.04.2011
account in relation to the stations
(1) Cumulative constraints associated to the available time of work in the
stations.
(2) Precedence constraints created by the requirement of some tasks to be
performed after other tasks have been nished.
Any other problem taking into account any additional considerations like
incompatibilities between tasks, dierent line shapes, space constraints or parallel
stations, between many others, are included in the GALBP class.[3]
To nd an optimal solution for this kind of problems you will need to use either
exact methods or heuristics methods.
Generally heuristics are more ecient
and in this letter we will use that method.
3 Findings, conclusion and recommendations
We did take closer look on four data les and found their cycle time with two
seprate programs, Matlab and Gusek. Whith their help we could nd LE(e.Line
eciency), SI(e.Smoothness index) and LT(e.Total time on the assembly lines),
those numbers are kept in the Appendix. It was not simulare to drive the data
in Matlab or Gusek, Matlab did nd solution fast but the SI was greater, which
tell us that Gusek showed lot better solution (more balanced). Gusek did end up
whit eighter very good solution or infesible solution, it had to run for a couple
of hours sometimes to get some values. When we had few tasks it did take few
seconds for Gusek but only part of a second for Matlab. Both programs came up
whith simular solution when the problems weren´t to hard. Heuristic method,
Longest time task and GNS showed not much dierence but if they did then
GNS had little better solution.
3
Aðgerðagreining
Assembly Line Balancing
10.04.2011
350
300
Right value
GUSEK
MATLAB (long)
MATLAB (followers)
Cycle time
250
200
150
100
50
0
B(m=7)
B(m=14)
K(m=7)
K(m=6)
T(m=12) T(m=17)
Mynd 1: Matlab plot from selected data les, b is for buxey, k is for kilbridge,
t is for tonge, m for number of workstations.
Matlab does nd an solution a lot quicker than Gusek but its value is often
not good enough, while Gusek takes its time to nd solution that is good enough.
When the problems become bigger and harder you will often have to give some
time limit for how long the programs can operate. On the bar graph above are
taken couple of our data set (see data). For example, rst you see Buxey whit
7 workstations optimized whit dierent programs compared to the real value.
After closer look you can see that Gusek is approaching better than Matlab.
That is maybe reverse to some bars here above but that is because of the time
limit we gave the programs and how they operate.
4 Methods
4.1
Theory
We want to design an assembly line consisting of
consisting of
n
m
work stations for a product
tasks. Each workstation preforms a number of tasks,
wj
, on an
item before passing it on to the next workstation in the assembly line.
Each
task has an indivisible operation time , ti , wich is assumed to be integral. Each
product spends the same amount of time at each workstation, called
C. The workload of workstation
j
is
wj =
∑
ti , (1)
i∈Wj
and its idle time or slack time is
sj = C − wj , (2)
4
cycle time
,
Aðgerðagreining
Assembly Line Balancing
10.04.2011
and the sum of all idle times is called balance delay time,
Due to technical restrictions there are
S=
precedence constraints
∑m
j=1 sj .
on the tasks,
partially specify the sequence for the assembly line production e.g. one can't
screw a bolt before drilling a hole. An immediate precedence matrix, P, is a binary matrix of dimension nxn, where P(i,j)=1 if task j is an immediate successor
to task i, 0 otherwise. An immediate followers matrix ,F, is simply the transpose
of P. An example of ALBP is given in Fig.1 with n = 9. The task index is given
within the circle; its operation time is given on the upper right hand side of the
circle; the arrows show the direction of the precedence constraints for the tasks.
For example it shows that task 1 and 4 can start immediately; task 2 can start
after task 1 has been completed; task 6 can start when both tasks 1 and 5 have
been completed, etc. Its immediate precedence and followers matrices are




P =



0
1
0
0
0
1
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0












F =



and
Simple assembly line balancing problem(SALBP)
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
1
0
0
0
1
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
1
0
0
0
1
0
0
0
0
0
0
0
0
0
1
0
(1)
describes a mass-production
of a homogeneous product with a known production process; paced line, i.e.,it is
assumed that the time to move items between stations is negligible; xed cycle
time; deterministic operation times; only assignment restrictions are precedence
constraints; serial line layout with
m
stations; all workstations are uniform, i.e.,
equally equipped regarding workers and machinery; and lastly line eciency is
to be maximized,[8].SALBP has several subcategories. The rst
is of type 1 (SALBP-1) and its objective function is to minimixe the number
of workstations,
m
. This may have to do with the cycle time being related to
the workers shifts duration. Other subcategory is of type 2(SALBP-2) and its
objective function is to minimize the cycle time, C , in other words minimize
the amount of work on the busiest workstation, i.e. the assembly line's bott1
leneck, thereby maximizing the production rate,
C , og the assembly line. In a
job shop scheduling context this is equivalent to minimizing the makespan on
identical parallel machines. Another subcategory SALBP-E combines these two
objective functions, i.e., minimize cycle time and number of stations in order to
maximize the line's eciency.
Lince balance
refers to nding a feasible solution to ALBP in such a manner
that each task is assigned to exactly one workstation and fullling its precedence
constraints and each station's workload does not exceed the cycle time. A simple
station- oriented algorithm is given in Fig.3. Of course there are many slightly
dierent heuristic rules that can be applied, or assign the algorithm in a taskoriented manner, but as described in [8] station-oriented algorithms are more
ecient than had it been task-oriented.
There are several performance measures associated with ALBP [7,9,6], their
5




.



Aðgerðagreining
n
m
M
P
Assembly Line Balancing
number of tasks on the assembly line
number of workstations in the assembly line
maximum number of workstations
immediate precedence matrix of dimension
P (i, j) = 1
F
if task
j
if task
j
n × n,
is an immediate successor of task
immediate followers matrix of dimension
F (i, j) = 1
C
ti
Wj
wj
sj
S
10.04.2011
i,
0 otherwise.
n × n,
is an immediate follower of task
i,
0 otherwise.
cycle time of the assembly line
i
operation time of task
j -th workstation
∑
j -th workstation, wj = i∈Wj ti
the slacktime for the j -th workstation, sj = C − wj
∑m
balance delay time, S =
∑ j=1 sj
the set of tasks assigned to the
the workload of the
m
j=1
LE
line eciency,
LE =
SI
smoothness index,
LT
total time on the line,
wj
C·m
√
SI =
∑m
j=1 (C
− wj )2
LT = C · (m − 1) + wm
Mynd 2: Notation used in this paper
main measures being:
Line eciency
,LE, that shows the utilization of the line
as a ration between the total workload and by the cycle time multiplied by of
number of utilized machines,
∑m
LE =
Smoothness index
j=1
wj
C ∗m
.(4)
,SI, describes the relative smoothness for a given assembly, it
is derived from the slack times,
v
u∑
um 2
SI = t
sj .(5)
j=1
the smaller the SI the smoother the line is, and SI=0 indicating a perfect balance. Finally the
total time on the assembly line
, LT , tells how long time it
takes the product to be completed,
LT = C ∗ (m − 1) + wm .
4.2
Technology
Heuristic evaluation is a discount usability engineering method for quick, cheap,
and easy evaluation of a user interface design. Heuristic evaluation is the most
popular of the usability inspection methods.
Heuristic evaluation is done as
a systematic inspection of a user interface design for usability.
6
The goal of
Aðgerðagreining
Assembly Line Balancing
10.04.2011
1 for j := 1 to M do (assign tasks on workstation)
2
Identify available tasks, A, whose predecessors have been assigned
a workstation ≤ j .
3
Determine from available tasks, At = {i | ∀i ∈ A : ti ≤ sj }
4
Choose a task i ∈ At by some heuristic.
5
if At = ∅ then break 6
if all tasks are assigned then return ALBP sequence using m := j
workstations 9 od
Mynd 3: Simple station-oriented algorithm for nding a solution to ALBP.
heuristic evaluation is to nd the usability problems in the design so that they
can be attended to as part of an iterative design process. Heuristic evaluation
involves having a small set of evaluators examine the interface and judge its
compliance with recognized usability principles (the "heuristics").[4]
5 references
1. Baybars, I.:A survey of exact algorithms for the simple assembly line balancing problem. Management Science(1986)
2.Betancourt, L.: ASALBP: the Alternative Subgraphs Assembly Line Balancing Problem. Formalization and Resolution Procedures(2007)
3.Bautista, J; Pereira, J.: A dynamic programming based heuristic for the
assembly line balancing problem (2009)
http://www.useit.com/papers/heuristic/ [4]
6 Appendix
Reiknirit/stærðfræðilíkan fyrir glpk.
1
2
3
4
5
6
7
8
9
10
11
12
#
#Reikniverkefni 2
#
/*set af akvardanabreytum*/
set workstations;
set tasks;
/*pharameters*/
param P{i in tasks,w in tasks};
param t{i in tasks};
7
Aðgerðagreining
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
Assembly Line Balancing
10.04.2011
/*Akvordunarbreyta */
var x{i in tasks,j in workstations}, binary;
var Ct ≥0, integer;
/*Minimize cicle time*/
minimize z:Ct;
/* Skorur */
s.t. pre{i in tasks,w in tasks : P[i,w] = 1}:
sum{j in workstations} j*x[w,j] ≤ sum{j in workstations} j*x[i,j];
s.t. workst{i in tasks} : sum{j in workstations} x[i,j] =1;
s.t. bla{j in workstations}: sum{i in tasks} t[i]*x[i,j]≤Ct;
solve;
display z;
data;
set tasks:= 1 2 3 4 5 6 7 8 9;
set workstations:= 1 2 3 4 5 6;
param t :=
1
6
2
6
3
4
4
4
5
5
6
4
7
5
8
2
9
9;
param
1 0
2 1
3 0
4 0
5 0
6 1
7 0
8 0
9 0
P : 1
0 0
0 0
1 0
0 0
0 0
0 0
0 0
0 0
0 0
2 3 4
0 0
0 0
0 0
0 0
1 0
0 1
0 0
0 0
0 0
5 6 7
0 0
0 0
0 0
0 0
0 0
0 0
1 0
0 1
0 0
8 9 :=
0 0
0 0
0 0
0 0
0 0
0 0
0 0
0 0
1 0;
end;
8
Aðgerðagreining
Assembly Line Balancing
10.04.2011
We used GLPK to calculate the minimum cycle time for example 1.
example included six workstations and 9 Tasks.
The
In the program reikn2.mod
which can be seen in the appendix, we begin to dene workstations and tasks,
then set the matrix P as parameter, it contains information for tasks.
Decisions variables were only x [i, j] and Ct (cycle time).
The
X [i, j] is actually
a variable that describes what tasks are carried out in worsktations.Then were
the constraints set up as they were in the mathematical model.
data le, containing the information that were given.
We created
The program sequence
each task down to a workstation and nds the cycle time. For this sample the
z (cycle time) = 9
6.1
Mathematical models
According to the optimization objective considered, four versions of SALBP are
distinguished (Scholl (1999)):
SALBP-1: minimizes the number of workstations m given a cycle time ct.
SALBP-2: aims at minimizing the cycle time ct given the number of workstations m.
SALBP-E: seeks to maximize the line eciency E, where E=tsum/(mct) and
tsum is the summation of all task processing times.
SALBP-F: is a feasibility problem that tries to establish whether a feasible task
assignment exists for a given cycle time ct and a number of workstations m. [2]
The cycle time is the variable to be optimized, i.e., objective function(i) furthermore, as the number of workstations is a given parameter, since all workstations existence variables
yj
are equal to 1. This is for SALBP-2.
minimizez = tc(i)
m
∑
xi j = 1(ii)
j=1
n
∑
m
∑
j=1
i = 1ti xi j ≤ ct∀j(iii)
jxp j ≤
m
∑
jxi j, ∈ P Dt (iv)
j=1
9
Aðgerðagreining
6.2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
1
2
3
4
5
Assembly Line Balancing
10.04.2011
Applications
function [C_longest,C_maxf] = salbp2(n,t,P,F,m,Cmin)
mstar_v_longtt = [];
mstar_v_maxf = [];
seq_v_longtt = {};
seq_v_maxf = {};
C_v_longtt = [];
C_vigur_maxf = [];
tilv_longtt = 0;
tilv_maxf = 0;
tilv_alls = 0;
for i = Cmin:sum(t);
[seq1,mstar1] = salbp_Longesttt(n,t,P,i);
[seq2,mstar2] = salbp_maxf(n,t,P,F,i);
seq_v_longtt = {seq_v_longtt seq1};
seq_v_maxf = {seq_v_maxf seq2};
if (mstar1 == m) && (tilv_longtt == 0)
C_longest = i;
C_v_longtt = [C_v_longtt i];
tilv_longtt = 1;
end
if (mstar2 == m) && (tilv_maxf == 0)
C_maxf = i;
C_cigur_maxf = [C_vigur_maxf i];
tilv_maxf = 1;
end
if (tilv_maxf == 1) && (tilv_longtt == 1) && (tilv_alls == 0)
break
end
if tilv_longtt == 0
C_v_longtt = [C_v_longtt i];
end
if tilv_maxf == 0
mstar_v_longtt = [mstar_v_longtt mstar1];
end
end
function [seq,mstar] = salbp_Longesttt(n,t,P,C)
M=n; % upper bound on number of workstations needed
nr_unassigned=n; % Intially all tasks are unassigned
10
Aðgerðagreining
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
1
2
3
4
5
6
Assembly Line Balancing
10.04.2011
unassigned=1:n;
s=C*ones(M,1); % Initially the slack on all workstations is C
seq = [];
for j=1:M % Assign tasks on workstation
while 1
% Identify available tasks, A, whose predecessors have been assigned
A=[];
for i=unassigned
if P(i,unassigned)==zeros(1,nr_unassigned), A=[A i]; end
end
% Determine from available tasks, Afit = {i | for all i in A : t(i)≤s(j)
Afit=[];
for i=A
if t(i)≤s(j), Afit=[Afit i]; end
end
% if Afit is empty then break
if isempty(Afit),
break % from the while-loop and procede to next machine j+1
end
% Choose a task i in Afit by some heuristic; at least two distinctly
% different heuristics (hint: read the introduction)
%i = heuristic(Afit,...); % YOUR TASK
i = Longesttt(Afit, t)
seq = [seq i j];
s(j)=s(j)-t(i); % update the slack
unassigned=setdiff(unassigned,i);
nr_unassigned=nr_unassigned-1;
end
% if all tasks are assigned then return ALBP sequence using m:= j
% workstations
if isempty(unassigned)
mstar = j;
break; % from the for-loop
end
end
end
function [seq,mstar] = salbp_maxf(n,t,P,F,C)
M=n; % upper bound on number of workstations needed
nr_unassigned=n; % Intially all tasks are unassigned
unassigned=1:n;
11
Aðgerðagreining
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
1
2
3
4
5
6
7
8
Assembly Line Balancing
10.04.2011
s=C*ones(M,1); % Initially the slack on all workstations is C
seq = [];
for j=1:M % Assign tasks on workstation
while 1
% Identify available tasks, A, whose predecessors have been assigned
A=[];
for i=unassigned
if P(i,unassigned)==zeros(1,nr_unassigned), A=[A i]; end
end
% Determine from available tasks, Afit = {i | for all i in A : t(i)≤s(j)
Afit=[];
for i=A
if t(i)≤s(j), Afit=[Afit i]; end
end
% if Afit is empty then break
if isempty(Afit),
break % from the while-loop and procede to next machine j+1
end
% Choose a task i in Afit by some heuristic; at least two distinctly
% different heuristics (hint: read the introduction)
%i = heuristic(Afit,...); % YOUR TASK
i = maxfollowers(Afit, nr_unassigned, F)
seq = [seq i j];
s(j)=s(j)-t(i); % update the slack
unassigned=setdiff(unassigned,i);
nr_unassigned=nr_unassigned-1;
end
% if all tasks are assigned then return ALBP sequence using m:= j
% workstations
if isempty(unassigned)
mstar = j;
break; % from the for-loop
end
end
end
function i = maxf(Afit, nr_unassigned, F)
fjoldi_e = [];
h = 1;
for k = Afit
fjoldi_e(h) = length(find(F(k,1:nr_unassigned)));
h = h+1;
end
12
Aðgerðagreining
9
10
11
12
13
14
15
16
17
18
19
1
2
3
4
5
6
7
8
Assembly Line Balancing
[margir,nr_margir] = max(fjoldi_e);
if margir == 0
lokastakid = Afit(1);
else
lokastakid = Afit(nr_margir);
end
i = lokastakid;
end
function i = Longesttt(Afit,t)
T = [];
for k = Afit
T = [T t(k)];
end
Stort = find(max(T));
i = Afit(Stort);
end
13
10.04.2011