A new method for functional assembly plan generation and evaluation. Implementation in CapLog, an efficient software

Abstract

Designing an assembly system is a complex task that is broken down into different steps that deal with various representations of the product, the assembly plan, and the assembly process plan. Each step faces a huge combinatorial explosion problem. Many research works have focused on the generation of assembly plans. They often fail to represent the logistic functions (choice of primary/secondary subassemblies and their orientations implying specific logistic operations). The resulting assembly sequences are therefore not fully satisfactory from an operational point of view. In the 1990s, the concept of the functional assembly plan (FAP) was introduced to refine the assembly plans with these key inputs that are essential to consider before proceeding with the next step concerning the assembly process plan. However, in the literature, there is no method to systematically generate, evaluate, and select the most relevant FAPs. In this paper, we propose an original semi-automated method to generate FAPs and to evaluate them. This method combines automated steps and user’s intervention to limit the phenomenon of combinatorial explosion and to make the solution explainable. It allows the user to find the “lowest cost” FAP, according to predefined evaluation criteria, without fully evaluating each potential FAP. This method and its associated procedure have been used to improve an existing software, CapLog, efficient for the optimization of manufacturing systems, like end-of-life systems or assembly systems. A case study is used to illustrate the steps of the proposed method.

Appendices

Appendix 1 Notations used in XP E01-015-4 standard to represent functional assembly (CETIM courtesy)

The notations used to represent the functional assembly plans (FAP) are shown in Table 1 (an example is presented in Fig. 4).

Table 1 Symbolisms used to represent functional assembly plans (FAP)

Appendix 2 Optimization problem and application example of the method to generate the “best” FAP

2.1 Formulation of the optimization problem

2.1.1 Input data modelling

FAP net modelling

The FAP net can be modelled by a graph G(A, F, E_A→F, E_F→A) where:

• A is the set of the nodes representing aggregates

• F is the set of the nodes representing functions

• E_A→F is the set of oriented edges (arcs) from A to F; e_i,j is an arc of E_A→F

• E_F→A is the set of oriented edges (arcs) from F to A; e_j',i' is an arc of E_F→A

• N is the cardinality of A

• a_N is the root aggregate (that represents the end product)

• a_i is an aggregate

• A_L is the subset of A including the leaf aggregates (the set of elementary components)

• f_j is a function

Main properties of G

• G is a bipartite graph (aggregates and functions)

• G is a directed graph

• G is a connected graph

• G is without loop

G is an AND/OR graph where:

• To perform a function f_j of F, two aggregates a_i1 and a_i2 of A (where e_i1,j and e_i2,j belong to E_A→F ) are requested; this property describes an AND condition. f_j produces only one single result, the aggregate a_i’ of A (where e_j,i’ belongs to E_F→A).

• An aggregate a_i of A may be produced by more than one function f_j of F. This is indicated by each arc e_j,i of E_F→A. By the same way, an aggregate a_i of A may be used by more than one function f_j of F. This is indicated by each arc e_i,j of E_A→F. These two properties describe OR conditions.

2.1.2 Parameters

Let be the parameters:

• C_ai the cost of aggregate a_i

• C_fj the cost of function f_j

Important note: these costs are input data as parameters of the proposed modelling. However, it seems irrelevant to know all of them at the beginning of the problem solving, because evaluating the cost of an aggregate or function is time consuming and if this aggregate or function is not included in the FAP generation, this evaluation will be useless. In other words, “a good FAP generation procedure should minimize a cost function and at the same time limit the work time of the assembly expert.”

2.1.3 Modelling of the optimization problem

The FAP net may include many FAP. Each FAP can be represented by a tree. We search for one FAP that presents the lowest cost in the FAP net. A lowest cost FAP can be represented by a tree T issued from the G graph associated to the FAP net. We note T (A’, F’, E’_A→F, E’_F→A) is such a tree that respects the following constraints:

• T is a bipartite sub-graph of G (A’⊂A, F’⊂F, E’_A→F ⊂E_A→F, and E’_F→A ⊂E_F→A)

• T is a tree

• T includes every leaf aggregate (A_L⊂A’) and the root aggregate (the end product, a_N)

• T is only an AND graph (where OR conditions are removed) then for each a_i of A:

  • Zero or only one arc of E_F→A ends to a_i (zero if a_i is a leaf that describes an elementary component and if the aggregate is not used)

  • Zero or only one arc of E_A→F starts from a_i (zero if a_i is the root of T that describes the end product and zero if the corresponding functions are not performed)

Note: the simplified notation T (A’,F’) is sufficient to describe a FAP because the arcs of this tree can be deduced from its nodes.

Decision variables

Let x_A→F(i,j) and x_F→A(j,i) be boolean variables associated to each arc of respectively E_A→F and E_F→A.

x _A→F(i,j) = 1 if e_{i, j} ∈ E’_A → F and 0 otherwise.

By the same way, x_F→A(j,i) = 1 if e_{j, i} ∈ E’_F → A and 0 otherwise.

Cost function

The lowest cost FAP is a bipartite tree of G, that is called T and that presents the minimum cost denoted C_TotalMin:

$$\textrm{Cost}(T)={C}_{\textrm{TotalMin}}\left({a}_{\textrm{N}}\right)=\min \sum_{\textrm{j}}{x}_{\textrm{F}\to \textrm{A}}\left(\textrm{j},\textrm{i}\right).{\textrm{Cf}}_{\textrm{j}}+\sum_{\textrm{i}}{x}_{\textrm{A}\to \textrm{F}}\left(\textrm{i},\textrm{j}\right).{\textrm{Ca}}_{\textrm{i}}$$

T can be deduced from the two sets of decision variables where x_A→F(i,j) and x_F→A(j,i) are equal to 1.

Constraints

The used constraints are formulated in Table 2.

Table 2 Formulation of the constraints

This optimization problem corresponds to an integer linear programming model with binary (logical) variables (called binary integer programming). This problem is known to be NP-complete. As the number of variables in this problem may be high, this problem can not be solved by exploring all admissible solutions.

In addition, since an objective is to spare user’s time, an algorithm inspired from a branch-and-bound algorithm could be efficient.

When we consider the first fourth constraints, they can describe a top-down approach to explore the graph and to select a feasible assembly tree:

• C1 is an initialization constraint (the end product as the root aggregate has to be assembled).

• C2 requires that only one function has to produce this aggregate.

• C3 requires that two aggregates are required by the chosen function.

• C2 requires that only one function has to produce aggregates selected with C3.

• And so on, C3, then C2…

• Until an aggregate is a leaf aggregate, then C4 indicates that only one function uses this aggregate.

2.2 Proposed procedure

At the beginning of the solving of a real problem, it is assumed that the cost parameters (see Appendix 2 Parameters) are not known. One of the objectives of the proposed procedure is to save the user’s time. Then, it is proposed to evaluate the costs of functions and aggregates only when necessary. It is hoped that some evaluations of “irrelevant” functions and aggregates could be avoided.

As described in Appendix 2 the proposed method is presented in Fig. 7. It aims to extract the “lowest cost” FAP (i.e., one with the lowest cost) from a FAP net. The following procedure lies on an adaptation of the principles of the branch-and-bound algorithms. The algorithm is not really a branch-and-bound algorithm since it mixes automated and manual steps. However, since an objective is to minimize the number of user’s solicitations (to save his/her time), branch-and-bound principles seem to be efficient for this type of problems by avoiding to completely explore trees whose cumulative costs are higher than the current lowest cumulative cost.

The method can be transposed into the procedure shown in Fig. 13. Steps 1 and 4, shown in red, are manual (user’s solicitations). The others are automated.

Fig. 13

Procedure to extract the “lowest cost” FAP from a FAP net

2.3 Application

In this appendix, it is proposed to apply this procedure to the theoretical example shown in Fig. 14. All local costs of aggregates (in red) and functions (in green) are indicated. Note, however, that the procedure does not require all this data to be known. It will ask the user to document only the relevant data (related to the branches being considered).

Fig 14

Data of the application example, a theorical FAP net

The aim of the proposed method is to find the lowest cost and the corresponding FAP without exploring the entire net and then without evaluating the cost of each function or aggregate.

For this example, it is possible to explore the entire net. The “lowest cost” FAP included in this FAP net contains functions and aggregates ({A,B,C,D,AB,CD,ABCD},{F11, F13, F32}) and its costs are 3081. The “highest cost” is 3353.

2.3.1 Procedure initialisation

The results of steps 1 and 2 of the procedure in Fig. 13 are the intermediate costs displayed in Fig. 15.

Fig 15

Procedure applied to the theorical FAP net—data initialization

Step 0: Initialize all costs to 0

Initially, the functions and aggregates are not evaluated. Their costs (penalties) are set to 0.

Step 1: Evaluate end aggregates (end product)

The procedure asks the expert to evaluate the cost of the end product (ABCD). In the example, she/he knows that it equals 1001. At this step, the output flow of FAP net, that is the C_TotalMin (ABCD), equals 1001 (Fig. 15).

2.3.2 First loop of the procedure

After the initialization steps 0 and 1, the current output flow of FAP net is 1001 (C_TotalMin (ABCD) = 1001).

Step 2: Search for the first partial cumulative cheapest FAP

FAP = ({ABCD},∅) and C_TotalMin (ABCD) = 1001

(See notation in Appendix D for the FAP writing).

Q: Is this FAP complete?

FAP = ({ABCD},∅) does not describe a full assembly process for the end product ABCD.

No

Step 3: Search for the first non-evaluated upstream function that presents the lowest cumulative cost

Input flows that produce ABCD in Fig. 15 have a cumulative cost that equals to 0. Usually, the cheapest one (lowest cost) is selected. In this particular case where every cumulative flow is equal to the others, the first one is selected. Then, function F31 and its linked aggregates ABC and D are selected to be studied.

Choose F31: FAP = ({ABCD,BCA,D},{F31})

Step 4: Evaluate this function and its input aggregates

The expert estimates the cost of function F31 and enters the value (here 2001—see Fig. 16).

Fig 16

Procedure applied to the theorical FAP net—first loop

Aggregates ABC and D allow to perform function F31. The expert has to evaluate the cost of aggregate ABC (i.e., 101) and the cost of aggregate D (i.e., 4).

C _F31 = 2001; C_BCA = 101; C_D = 4

Step 5: Re-evaluate cumulative costs of the FAP net

Using the formula in Fig. 8, each flow that links an aggregate to a function, or a function to an aggregate, can be evaluated in terms of cumulative costs. This evaluation process starts from the leaf aggregates of the FAP net (elementary components) and ends to the root aggregate (end product).

Gm_D = 4 then

Gm_F13 = Gm_CD = Gm_F22 = Gm_F32 = Gm_BCD = GmF33 = Gm_ABCD = 4

Gm_BCA + Gm_D + C_F31 = 101 + 4 + 2001 = 2016

Finally, Gm_ABCD = min (2106, 4, 4) + 1001 = 1005 (See Fig. 16)

Remarks:

• 1. If each aggregate has a local cost of 0 (no penalty) and each function also has a local cost of 0 (also no penalty), the lowest cumulative cost of the FAP net is found and is also 0.

• 2. At each loop of the procedure, step 5 must be performed to propagate the new cost information throughout the net. For example, as the cost of aggregate D is 4, then at this step, the cumulative flow cost from CD to F22 is also 4.

Output data of the first loop (Fig. 16)

According to the execution of the first loop of this procedure, the current output flow cost of FAP net is now 1005 (C_TotalMin (ABCD) = 1005).

2.3.3 Intermediate loops of the procedure

The following loops performed by the procedure lead to the following evaluations:

Loop 2

Step 2: Search for the first partial cumulated cheapest FAP

FAP = ({ABCD},∅) and C_TotalMin (ABCD) = 1005

Q: Is this FAP complete?

No

Step 3: Search for the first non-evaluated upstream function that presents the cheapest cumulative cost

Choose F32; FAP = ({ABCD,AB,CD},{F32})

Step 4: Evaluate this function and its input aggregates

C _F32 = 2002; C_AB = 11; C_CD = 13

Step 5: Re-evaluate cumulative costs of the FAP net

Gm_AB = 11 then Gm_F23 = 11

Gm_CD = 4+13 = 17 then Gm_F22

Gm_ABC = min (0,11) + 101 = 101; Gm_F31 = 101 + 4 + 2001 = 2106

Gm_F33 = 4 + 0 + 0 = 4

Finally, Gm_ABCD = min (2106,2030,4) + 1001 = 1005

Loop 3

Step 2: Search for the first partial cumulated cheapest FAP

FAP = ({ABCD},∅) and C_TotalMin (ABCD) = 1005

Q: Is this FAP complete?

No

Step 3: Search for the first non-evaluated upstream function that presents the cheapest cumulative cost

Choose F33; FAP = ({ABCD,A,BCD},{F33})

Step 4: Evaluate this function and its input aggregates

C _F33 = 2003; C_(A) = 1; C_(BCD) = 102

Step 5: Re-evaluate cumulative costs of the FAP net

C _A = 1 then Gm_F11 = 0 + 1 + 0 = 1 and Gm_AB = 1 + 11 = 12

C _BCD = 102 then Gm_BCD = min (17,4) + 102 = 106

Then Gm_F31 = 102 + 4 + 2001 = 2107

Then Gm_F33 = 1 + 106 + 2003 = 2110 and Gm_F32 = 12 + 17 + 2002 = 2031

Then Gm_F32 = 12 + 17 + 2002 = 2031

Finally, Gm_ABCD = min (2107,2031,2110) + 1001 = 3032

Loop 4

Step 2-Search for the first partial cumulated cheapest FAP

FAP = ({ABCD,AB,CD},{F32}) and C_TotalMin (ABCD) = 3032

Q: Is this FAP complete?

No

Step 3: Search for the first non-evaluated upstream function that presents the cheapest cumulative cost

Choose F11; FAP = ({ABCD,AB,CD,A,B},{F32,F11})

Step 4: Evaluate this function and its input aggregates

C_F11 = 21; C_A = 1 (already known); C_(B) = 2

Step 5: Re-evaluate cumulative costs of the FAP net

Recompute Gm of aggregates and functions.

Finally, Gm_ABCD = min (2109,2054,2112) + 1001 = 3055

Loop 5

Step 2: Search for the first partial cumulated cheapest FAP

FAP = ({ABCD,AB,CD},{F32,F11}) and C_TotalMin (ABCD) = 3035

Q: Is this FAP complete?

No

Step 3: Search for the first non-evaluated upstream function that presents the cheapest cumulative cost

Choose F13; FAP = ({ABCD,AB,CD,A,B,C,D},{F32,F11,F13})

Step 4: Evaluate this function and its input aggregates

C _F13 = 23; C_C = 3; C_D = 4 (already known)

Step 5: Reevaluate cumulative costs of the FAP net

Recompute Gm of aggregates and functions.

Finally, Gm_ABCD = min (2112, 2080, 2115) + 1001 = 3081

Loop 6 (last loop)

Step 2: Search for the first partial cumulated cheapest FAP

FAP = ({ABCD,AB,CD,A,B,C,D},{F32,F11,F13}) and C_TotalMin (ABCD) = 3081

Q: Is this FAP complete?

Yes

The last found partial FAP describes a full assembly process for the end product ABCD (each of its functions and each of its aggregates are evaluated). The loop can exit to step 6.

Step 6: Display the cheapest FAP and the corresponding cumulative cost (end of the procedure)

Now, the output flow cost of the FAP net (end node) presents the lowest cumulative cost of 3081 (C_TotalMin (ABCD) = 3081). The final result is presented in Fig. 17, through its bold arrows. Then, the procedure leads to the discover of the “lowest cost” FAP = ({ABCD,AB,CD,A,B,C,D},{F32,F11,F13}) and its C_TotalMin (ABCD) = 3081. In this example, the lowest cost FAP is unique.

Fig. 17

Procedure applied to the theorical FAP net—last loop and final results

2.4 Conclusion

In this appendix, we have formulated the optimization problem for the search of the best FAP in a FAP net, as an integer linear programming model with binary (logical) variables. It is known to be NP-Complete.

As the number of variables in this problem may be high (in the case of complex products), it may be complicated to solve it by exploring all admissible solutions. Then, we have proposed an original procedure that combines automated steps and manual intervention by the user to evaluate the local costs of only a reduced subset of the aggregates and functions. It enables the assembly expert to generate a lowest cost FAP and at the same time limit his/her work time due to the evaluation of the costs of the functions and aggregates in the FAP net.

We have applied this procedure to an example to illustrate its interest.

In this example, the “lowest cost” FAP included in this FAP net is 3081. For information, the “highest cost” is 3353. Only 5/10 functions (in red) and 9/10 aggregates (in green—except (BC)) required user intervention (see Fig. 17). There is, therefore, no need to pre-evaluate each node (aggregate, function) in the FAP net. It is not necessary to explore all paths (all FAPs) in the net. Only the cumulative costs need to be recalculated simply and quickly when the user evaluates a new cost of a function or of an aggregate. The cheapest FAP can be deduced easily.