Efnisyrlit. Aðgerðagreining Assembly Line Balancing Title 2. 2 executive summary Introduction... 2

Transcription

1 Efnisyrlit 1 Title 2 2 executive summary Introduction Findings, conclusion and recommendations 3 4 Methods Theory Technology references 7 6 Appendix Mathematical models Applications

2 Aðgerðagreining(IÐN401G) Reikniverkefni 2 Assembly Line Balancing Axel Viðarsson Ágúst Þorri Tryggvason Davíð Freyr Hlynsson

3 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 Introduction An 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, 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

4 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

5 Right value GUSEK MATLAB (long) MATLAB (followers) Cycle time 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 m work stations for a product consisting of n tasks. Each workstation preforms a number of tasks, w j, on an item before passing it on to the next workstation in the assembly line. Each task has an indivisible operation time, t i, wich is assumed to be integral. Each product spends the same amount of time at each workstation, called cycle time, C. The workload of workstation j is w j = i W j t i, (1) and its idle time or slack time is s j = C w j, (2) 4

6 and the sum of all idle times is called balance delay time, S = m j=1 s j. Due to technical restrictions there are precedence constraints 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 = and F = (1) Simple assembly line balancing problem(salbp) 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 bott- 1 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

7 n number of tasks on the assembly line m number of workstations in the assembly line M maximum number of workstations P immediate precedence matrix of dimension n n, P (i, j) = 1 if task j is an immediate successor of task i, 0 otherwise. F immediate followers matrix of dimension n n, F (i, j) = 1 if task j is an immediate follower of task i, 0 otherwise. C cycle time of the assembly line t i operation time of task i W j the set of tasks assigned to the j-th workstation w j the workload of the j-th workstation, w j = i W j t i s j the slacktime for the j-th workstation, s j = C w j S balance delay time, S = m LE line eciency, LE = m j=1 w j C m j=1 s j SI smoothness index, SI = m j=1 (C w j) 2 LT total time on the line, LT = C (m 1) + w m 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 j=1 LE = w j C m.(4) Smoothness index,si, describes the relative smoothness for a given assembly, it is derived from the slack times, m SI = s 2 j.(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) + w m. 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. The goal of 6

8 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, A t = {i i A : t i s j } 4 Choose a task i A t by some heuristic. 5 if A t = 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) 4. [4] 5.Ingimundardóttir, H.: Assembly line balancing (2011) 6 Appendix Reiknirit/stærðfræðilíkan fyrir glpk. 1 # 2 #Reikniverkefni 2 3 # 4 5 /*set af akvardanabreytum*/ 6 set workstations; 7 set tasks; /*pharameters*/ 7

9 11 param P{i in tasks,w in tasks}; 12 param t{i in tasks}; /*Akvordunarbreyta */ 17 var x{i in tasks,j in workstations}, binary; 18 var Ct 0, integer; /*Minimize cicle time*/ 22 minimize z:ct; /*Skorur*/ s.t. pre{i in tasks,w in tasks : P[i,w] = 1}: 27 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; 1 data; 2 3 set tasks:= ; 4 set workstations:= ; 5 6 param t := ; param P : := ;

10 30 31 end; We used GLPK to calculate the minimum cycle time for example 1. The example included six workstations and 9 Tasks. 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. The Decisions variables were only x [i, j] and Ct (cycle time). 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. We created data le, containing the information that were given. The program sequence each task down to a workstation and nds the cycle time. For this sample the z (cycle time) = 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 y j are equal to 1. This is for SALBP-2. minimizez = tc(i) m x i j = 1(ii) j=1 n i = 1ti x i j ct j(iii) m m jx p j jx i j, P D t (iv) j=1 j=1 9

11 6.2 Applications 1 function [C_longest,C_maxf] = salbp2(n,t,p,f,m,cmin) 2 3 mstar_v_longtt = []; 4 mstar_v_maxf = []; 5 6 seq_v_longtt = {}; 7 seq_v_maxf = {}; 8 9 C_v_longtt = []; 10 C_vigur_maxf = []; tilv_longtt = 0; 13 tilv_maxf = 0; 14 tilv_alls = 0; for i = Cmin:sum(t); 17 [seq1,mstar1] = salbp_longesttt(n,t,p,i); 18 [seq2,mstar2] = salbp_maxf(n,t,p,f,i); seq_v_longtt = {seq_v_longtt seq1}; 21 seq_v_maxf = {seq_v_maxf seq2}; if (mstar1 == m) && (tilv_longtt == 0) 24 C_longest = i; 25 C_v_longtt = [C_v_longtt i]; 26 tilv_longtt = 1; 27 end if (mstar2 == m) && (tilv_maxf == 0) 30 C_maxf = i; 31 C_cigur_maxf = [C_vigur_maxf i]; 32 tilv_maxf = 1; 33 end if (tilv_maxf == 1) && (tilv_longtt == 1) && (tilv_alls == 0) 36 break 37 end if tilv_longtt == 0 40 C_v_longtt = [C_v_longtt i]; 41 end if tilv_maxf == 0 44 mstar_v_longtt = [mstar_v_longtt mstar1]; 45 end 46 end 1 function [seq,mstar] = salbp_longesttt(n,t,p,c) 2 3 M=n; % upper bound on number of workstations needed 4 5 nr_unassigned=n; % Intially all tasks are unassigned 10

12 6 unassigned=1:n; 7 8 s=c*ones(m,1); % Initially the slack on all workstations is C 9 10 seq = []; for j=1:m % Assign tasks on workstation while 1 15 % Identify available tasks, A, whose predecessors have been assigned 16 A=[]; 17 for i=unassigned 18 if P(i,unassigned)==zeros(1,nr_unassigned), A=[A i]; end 19 end % Determine from available tasks, Afit = {i for all i in A : t(i) s(j) 22 Afit=[]; 23 for i=a 24 if t(i) s(j), Afit=[Afit i]; end 25 end % if Afit is empty then break 28 if isempty(afit), 29 break % from the while-loop and procede to next machine j+1 30 end % Choose a task i in Afit by some heuristic; at least two distinctly 33 % different heuristics (hint: read the introduction) 34 %i = heuristic(afit,...); % YOUR TASK i = Longesttt(Afit, t) 37 seq = [seq i j]; 38 s(j)=s(j)-t(i); % update the slack 39 unassigned=setdiff(unassigned,i); 40 nr_unassigned=nr_unassigned-1; end % if all tasks are assigned then return ALBP sequence using m:= j 46 % workstations 47 if isempty(unassigned) 48 mstar = j; 49 break; % from the for-loop 50 end end end 1 function [seq,mstar] = salbp_maxf(n,t,p,f,c) 2 3 M=n; % upper bound on number of workstations needed 4 5 nr_unassigned=n; % Intially all tasks are unassigned 6 unassigned=1:n; 11

13 7 8 s=c*ones(m,1); % Initially the slack on all workstations is C 9 10 seq = []; for j=1:m % Assign tasks on workstation while 1 15 % Identify available tasks, A, whose predecessors have been assigned 16 A=[]; 17 for i=unassigned 18 if P(i,unassigned)==zeros(1,nr_unassigned), A=[A i]; end 19 end % Determine from available tasks, Afit = {i for all i in A : t(i) s(j) 22 Afit=[]; 23 for i=a 24 if t(i) s(j), Afit=[Afit i]; end 25 end % if Afit is empty then break 28 if isempty(afit), 29 break % from the while-loop and procede to next machine j+1 30 end % Choose a task i in Afit by some heuristic; at least two distinctly 33 % different heuristics (hint: read the introduction) 34 %i = heuristic(afit,...); % YOUR TASK i = maxfollowers(afit, nr_unassigned, F) 37 seq = [seq i j]; 38 s(j)=s(j)-t(i); % update the slack 39 unassigned=setdiff(unassigned,i); 40 nr_unassigned=nr_unassigned-1; end % if all tasks are assigned then return ALBP sequence using m:= j 45 % workstations 46 if isempty(unassigned) 47 mstar = j; 48 break; % from the for-loop 49 end end end 1 function i = maxf(afit, nr_unassigned, F) 2 fjoldi_e = []; 3 4 h = 1; 5 for k = Afit 6 fjoldi_e(h) = length(find(f(k,1:nr_unassigned))); 7 h = h+1; 8 end 12

14 9 10 [margir,nr_margir] = max(fjoldi_e); if margir == 0 13 lokastakid = Afit(1); 14 else 15 lokastakid = Afit(nr_margir); 16 end i = lokastakid; 19 end 1 function i = Longesttt(Afit,t) 2 T = []; 3 for k = Afit 4 T = [T t(k)]; 5 end 6 Stort = find(max(t)); 7 i = Afit(Stort); 8 end 13