A constraint model for assembly planning

The importance of computer-aided process planning (CAPP) for assembly is widely recognized, as it holds the promise of eﬃcient and automated construction of solutions for a complex, geometrically, technologically, and economically constrained planning problem. This complexity led to the introduction of decomposition approaches, separating the macro-level planning problem that oversees the complete assembly process from the various micro-level problems that look into the details of individual assembly operations. The paper introduces a constraint model for solving the macro-level assembly planning problem based on a generic feature-based representation of the product and the assembly operations involved. Special attention is given to capturing the feedback from micro-level planners expressed in the form of feasibility cuts, and hence, to the integration of the approach into a complete CAPP workﬂow. Results on three case studies from diﬀerent industries are also presented to illustrate the practical applicability of the approach.


Introduction
Assembly is the ultimate step from the idea of products conceived by design to their form, structure and functions realized by production. Planning all the details of this transition requires the efficient use of information and knowledge from a number of different sources related to product design, parts manufactured, assembly technologies and processes as well as resources such as tools, fixtures, grasping and handling devices, human and robotic operators. The generated assembly plans should meet a rich set of requirements and comply with criteria like minimal cycle time, resource and energy efficiency, ergonomics to name only the most important ones. Primarily, the constraints are of geometric nature, as parts and subassemblies have to be moved and fit, fixtures and tools have to be applied as the assembly process advances in a more and more densely populated space.
No wonder assembly planning poses a number of intriguing questions for production engineering, from the very inception of the field: How to interpret a product model with the backdrop of the actually available assembly technology and resources? How to identify tasks which are potentially executable and how to define their appropriate ordering and resource assignment? How can one maintain, in the course of the assembly process, geometrical feasibility among any objects involved, let they be parts, subassemblies, tools, fixtures or any other elements of the production environment? In general, how to solve a problem when there is no monopoly of assembly planning knowledge and requirements may easily be proven irreconcilable?
The importance of automated computer-aided process planning (CAPP)also in assembly-was recognized early [1]. It became also clear and confirmed time and again since, that CAPP in general can be solved only by the application of well-proven decomposition principles [2]. While exploiting locality led to various feature-based models, hierarchical decomposition resulted in macro-level planning, which concentrates on combinatorial decisions as for ordering and resources of tasks, and micro-level planning activities, which are responsible for path planning, fine-tuning of technological process parameters, generation of work instructions or robot codes.
The goal of this paper is to present a constraint-based model for macrolevel assembly planning that provides a resolution to the above issues. As constraint models in general, it has a strong representation power to capture all important aspects of assembly planning. The model directly supports making decisions over the statement of the actual planning problem including assembly features and tasks, subassemblies, the ordering and resource assignment of tasks in a least-commitment manner. It is open to incorporate new constraints on the fly, as demanded by the micro-level analysis of partial solutions. Specifically, by means of generalized precedence constraints the model facilitates making new statements over the ordering relations of tasks and the resources assigned to them. With the progress of the assembly planning process a product model containing basically geometric information of parts and their relations is interpreted and enriched step by step with pieces of technological knowledge. The model assists a cautious approach to planning: if it gets over-constrained, the actual problem has indeed no solution, whereas one can be sure that a final plan, if it passes all micro-level evaluations, completely complies with the relevant domain knowledge and is optimal according to the given criterion. We focus here on the aspect of modelling and leave the solution of assembly planning problems to powerful constraint programming engines.
In what follows, Section 2 discusses the related literature, then Section 3 presents the generic planning workflow. Section 4 focuses on the statement of the constraint-based assembly planning problem, while the formal model of macro-level planning is presented in Section 5. According to the workflow, this model is extended with new constraints generated by micro-level evaluation as explained in Section 6. The results of computational experiments are summarized in Section 7, while Section 8 concludes the paper.

Related work
Traditionally, three main subproblems of assembly planning are distinguished in the literature, namely: Assembly Line Balancing (ALB), Assembly Path Planning (APP) and Assembly Sequence Planning (ASP). In addition to their different objectives, the different subproblems are usually separated by the applied representation of the problem as well [3]. There are a number of papers which focus on delivering solutions to one of the subfields, however, only a few integrated approaches exist [3,4,5].
In the environment of a single workcell, ALB can be assumed to be out of the scope and thus ASP and APP are subjects of solution efforts. ASP is typically formulated as a combinatorial optimization problem, while for APP solutions are usually produced by reasoning on a detailed geometrical model [6]. ASP is generally considered to be an NP-hard problem and therefore numerous heuristics and soft computing methods have been suggested to solving it, but classic optimization tools are also often applied [5,7,8,9]. Minimizing the changeovers, the number of assembly directions or the required time for the assembly are very common objective functions of ASP [5,10].
There are works on ASP which also consider the geometric feasibility of the resulting sequence. A general approach for combining ASP with geomet-ric reasoning is to construct a search space which is assumed to contain all the relevant geometrical and technological constraints. A key aspect here is the definition of the search space. A seminal paper tackles this problem [11], aimed at generating all feasible assembly sequences for a product. In [12] and [13] the concept of directional and non-directional blocking graphs were used in order to represent the geometrical constraints. In [14] the stereographical projections of parts are used to include the collision space into the assembly sequencing. The work presented in [15] generates assembly sequences directly from the CAD models, which can be later used in optimization. In [16], part interaction clusters are defined to generate the precedence constraints from geometrical data. The sequencing and planning is carried out in this search space. In [17], the geometric models of assemblies are translated into an attributed part layout graph in order to identify functional subassemblies, which provides the basis for an ASP model using particle swarm optimization. Another approach that uses subassembly identification from 3D models is presented in [18], which proposes the concept of disassembly interference graph and uses this information to generate feasible assembly sequences. The work introduced in [19] discusses generating part precedence diagrams automatically for assembly planning considering tool assignment and changeovers. By extracting contact relations between parts, [20] proposes an approach to find feasible disassembly paths for parts, thus obtaining a feasible assembly sequence. In [21], by identifying and removing the standard elements, a simplified assembly model is analysed by collision detection to generate all feasible assembly sequences.
Features are, also in assembly, the most traditional and broadly used concepts for matching means and ends of production [8]. Assembly features offer a representation which can contain the information required for defining and solving the macro-level optimization problem of ASP, but at the same time they can also represent the geometric data required for building up a detailed micro-level world necessary for APP [22,23]. Domain knowledge required for the correct realization of assembly features can be captured in terms of function blocks [24], and this approach can be extended to the adaptive and distributed control of assembly operations, too [25].
A hierarchical approach is presented in [26] for finding the optimal assembly sequence in 2D, which maximizes the assembly angles during the assembly. The set of feasible solutions is determined by analysing geometrical accessibility. In [27] a genetic algorithm is applied to minimize the number of assembly direction changes and the total stress for flexible parts. An ASP solution is presented in [28], which first extracts precedence constraints from the geometrical models and then a search loop is executed.
In [10] it is stated that a combination of a feature based model extended with expert rules can deliver more comprehensive results for CAPP. In [7], based on the lessons of a literature review, a general optimization scheme for ASP is recommended as an integral loop in any assembly planning process. Having a loop without external feedback, however, assumes that every information is available for conducting a successful search and leaves no room for injecting constraints back from a more detailed evaluation, which due to its complexity can not be part of the original search. In [29] a constraint programming based approach is introduced for solving CAPP in sheet metal bending, where the solver communicates with external experts through rulebased feedbacks, thus reducing the domain of decision variables in each iterative solution cycle. The approach of using external experts also appears in [30], where a hierarchical decomposition for task and motion planning is applied in order to reduce and postpone the execution of costly calculations. A similar approach also appears in [31], where a "logical layer" is applied for ASP and a "physical layer" is used for APP.
In [8,32] the authors already presented a feature-based hierarchical workflow for solving the assembly planning problem by the integration of sequencing, resource assignment and geometric validation, by applying a Benders decomposition scheme [33]. The macro-level solution was built around a mixed integer programming (MIP) solver for which disjunctive rules provided the feedback in each solution loop. A strong assumption of these works was that all assembly features to be realized were given in the input, and they had to form a tree-structured liaison graph. In the approach presented below, this assumption is lifted.

Feature-based assembly planning workflow
The assembly planner presented in the paper operates in an iterative, hierarchical, mixed-initiative CAPP workflow, which starts from the models of the assembled product and the applicable resources, and ends with the generation and post-processing of work instructions (Fig. 1). Here, the paper's main focus is set on the macro-level planning model. Still, in order to better position the approach and to highlight its relationship to other planning steps, the complete workflow and its key concepts are introduced briefly below.
The workflow starts from the geometric models of the parts composing the assembly, which are rigid, tolerance-free 3D objects characterized by their geometrical model. They are either individual parts, or composites merged from multiple related parts that must be assembled at the same time, using identical resources (e.g., multiple identical, parallel-axis screws joining the same parts). The application of composites helps reducing the size of the planning problem.
With parts positioned in their assembled state, connectivity analysis between them can be executed. The physical connections between the parts define the connectivity graph, whose nodes are the parts and an edge between two nodes denotes a contact between the two geometries [32]. However, physical connectivity alone does not characterize fully the assembly operations, hence the feature-based assembly planning model is completed by technology-specific feature parameters, such as torque, lead or threaded depth for screwing features [34].
The connectivity graph provides input for feature identification. A feature describes how two parts can be assembled together, by defining the relative movement between the parts and the applicable resources (e.g., fixtures, tools). Hence, a feature corresponds to an edge in the connectivity graph with meaningful technological content. However, not every edge of the connectivity graph belongs to an assembly feature: e.g., two geometries touching at their edges cannot be joined by a feature. Consequently, feature identification assigns assembly features to some of the connectivity edges. This defines the so-called liaison graph, over the same nodes as the connectivity graph, with a subset of the edges.
Accordingly, each feature realizes exactly one edge in the connectivity graph directly. Nevertheless, the same feature may realize further edges indirectly: if the involved parts take place in previously constructed subassemblies, then the feature realizes all the connectivity edges between the parts of the two sub-assemblies.
The assembly process is complete when every edge in the connectivity graph is realized, directly or indirectly. In particular, the assembly of K parts can be completed with directly realizing K −1 edges of the connectivity graph that form a spanning tree of the liaison graph.
Having a feature-based problem instance defined, the workflow follows with the solution loop, where first a macro-level combinatorial optimization problem is solved. This involves the selection of the features to be realized directly, their sequencing, as well as the assignment of resources. Its result is evaluated by detailed micro-level validation. Micro-level validation either fails and adds new constraints to the feature-based model (and thus to the macro-level), which ensure that the same failure cannot occur in subsequent iterations, or it succeeds and then the workflow is finished with post-processing.
This feature-based planning workflow is an improved version of that in [32]. A key new idea is reducing the necessary expert input to a pairwise partto-part analysis during feature identification, which is more comprehensible for human experts. This is made possible by allowing an arbitrary structure for the liaison graph, instead of the previous tree structure. The benefit of this generalization is illustrated on the sample assembly in Fig. 2a. The liaison graph has exactly the same edges as the connectivity graph (Fig. 2b). However, an ill-defined spanning tree of this liaison graph can render the planning problem infeasible, as it is shown on the upper version of the liaison graph: features A-B and A-C mutually block each other, end hence, there is no feasible sequencing for them. Yet, a different spanning tree of the liaison graph, shown in the lower part of Fig. 2b, leads to a feasible planning problem. In the previous approach, human decision was required to construct the liaison graph as a spanning tree of the connectivity graph, thus making room for such errors. These errors are now automatically avoided by the letting the solver select the features to realize.

Problem statement
The approach proposed in the paper minimizes the total assembly time of the feature-based assembly planning (sequencing and resource assignment) problem and thus providing a solution to the macro-level planning problem of the iterative, hierarchical CAPP workflow. The elements of the resulting assembly sequence are represented as tasks where each task is composed of: • the corresponding assembly feature, • an assigned tool, • an assigned fixture.
Taking two-handed assembly processes an assembly feature is F (ω, p, q, θ, tc, f c) where ω is the feature type (placing, insertion, and screwing are handled in the current implementation), p and q are the two parts joined by the feature, while θ defines the motion required to join parts p and q. The set of candidate tools and candidate fixtures are denoted by tc and f c, respectively.
The input of assembly planning is a feature-based problem instance (see Fig. 1) and in the macro-level the following assumptions are made: 1. The assembly features represent two-handed operations. 2. The assembly process is monotonous. 3. There is a set of applicable tools and fixtures specified as candidate resources for each feature. 4. Each fixture can grasp a specific part. When that part takes place in a subassembly, the fixture can hold that subassembly up to a given weight limit. 5. The duration of realizing an assembly feature is independent from its position in the plan and the assigned resources.
6. The changeover times of fixtures and tools are given and fixed.
In addition, the micro-level geometrical validation applied in the paper assumes that parts are rigid, tolerance-free 3D objects, which allows using collision detection for the validation of the plan. Removing assumption 1 would require a slight generalization of the macro-level planning model, since features would correspond to hyper-edges (rather than classical edges) in the liaison-graph. Assumption 2 is necessary to maintain an upper bound on the length of the assembly plan. Assumptions 3 and 4 capture resource capacities in a realistic way. Replacing assumptions 5 and 6 with sophisticated functions for determining the durations of tasks and changeovers from the actual subassemblies is a relevant direction for future research.
Taking the above assumptions, minimizing the total assembly time means minimizing the time required for realizing the assembly sequence. The time has two components here: the time required for completing each of the selected features and the changeover time required for using the assigned tools and fixtures. For warranting the feasibility of the solution, the following constraints have to be satisfied: • Every physical connection between the parts have to be realized. Accordingly, the features selected for direct realization have to form a spanning tree over the liaison graph of the assembly.
• The technological constraints (fixture weight limit, feature-tool and feature-fixture compatibilities) have to be fulfilled.
• The solution must be feasible on the micro level as well, which must be ensured by satisfying all feasibility cuts generated by micro-level validation.

Working example
In order to illustrate the proposed solution approach, a ball valve is used as a working example throughout the paper. The geometric model of this working example is shown in Fig. 3a: it consists of 13 parts and 16 features. The connectivity graph of the assembly is shown in Fig. 3b. The connectivity graph shows every physical connection between the parts as an edge, however, this does not necessarily result in a meaningful connection: e.g., between oring2 and the two inlets the connection would not imply a technologically meaningful assembly operation. This means that the liaison graph is a subgraph of the connectivity graph, with dashed edges left out from the former. The screws holding the top in its place (screw1..4) are identical with the same feature parameters, and therefore they are bound together to form a composite part.
The working example includes three fixtures, where one is the human hand, without a geometry, and others are fixtures grasping the house and the top. The usage of the human hand is restricted by a strict weight limit which does not allow holding the whole assembly.
The working example uses the same geometric models as in [32]. However, due to the lifted earlier assumption that the liaison graph of the assembly is a tree, this version includes more features. As a consequence, the required input is more generic and easier to create for experts, but the problem is combinatorially more challenging.  For solving the two-handed, monotonous CAPP problem with K unique parts, the number of required features (i.e., positions in the plan) is K − 1. The goal of the CAPP model is to find an optimal task sequence and resource assignment, which is given by finding the values of the following decision variables: • position of a given feature: {π l ∈ {0, ..., K − 1} : l = 1, ..., L}, where π l = 0 means that f l is not realized directly.

Model objective and constraints
The objective is minimizing the total time of completion, which means minimizing the sum of feature durations and changeover times: The solution has to satisfy the following constraints. First of all, the integrity of the solution is ensured by: • alldifferent except 0 constraint is applied to π l to enforce that each valid (i.e., non-zero) position is only assigned to one feature.
• alldifferent constraint is applied to φ i to enforce that every feature is realized at most once.
• channelling between π l and φ i enforces that (π l = i) In order to model the changeover needed for the first tool and fixture at zero position the dummy tool and fixture are assigned: τ 0 = 0 and χ 0 = 0, moreover τ j = 0, ∀j = 0 and χ j = 0, ∀j = 0. As a redundant constraint, it is specified explicitly that part-to-part connections are symmetric: ρ i,p,q = ρ i,q,p , ∀i, p, qρ i,p,q = ρ i,p,q , ∀i, p, q. After the completion of the last task, each pair of parts must be connected: ρ K−1,p,q = 1, ∀p, q. Before the first task, each part is connected only to itself: ρ 0,p,q ↔ (p = q), ∀p, q. A direct connection between two parts at a position means that the feature at that position joins those two parts. In general, two parts are connected at a given position in the plan if, directly or indirectly, they had been connected earlier by some feature: (1) Here, the first term on the r.h.s. of the logical biconditional means that parts p and q have already been connected in the previous position of the plan. The second and third terms encode that the two parts have already been connected to the parts assembled directly by the feature in position i of the plan.
At every position in the plan, the part grasped by the assigned fixture must be connected to one of the parts directly involved in the realized feature (which includes the case that the involved part itself is grasped). For selecting an applicable fixture, the following conjunction must hold (which are illustrated in Fig. 4): The assigned fixture must be among the candidate fixtures: f c φ i ,χ i = 1, ∀i and the same for candidate tools: tc φ i ,τ i = 1, ∀i.
Finally, it has to be warranted that the total weight of the grasped part and the parts connected is below the weight limit of the assigned fixture:
This generalized precedence constraint requires that either preceding task α d precedes at least one of the succeeding tasks β d,e in the plan (3), or the preceding task α d is left out of the plan (4), or one of the succeeding tasks β d,e is not present (5), or a different fixture (6) or a different tool (7) is used. As a special case, the dummy fixture γ d = f 0 (respectively, the dummy tool δ d = t 0 ) can be used to encode that modifying the fixture (tool) is not an option to satisfy the constraint:

Micro-level evaluation
Micro-level evaluation provides the feedback for closing the CAPP solution loop. Its purpose is to verify the geometric feasibility of each movement defined by the macro-level plan, and in case of any failure, to generate constraints that preclude the repeated occurrence of the same failure. The sequence calculated on the macro level is used for building up the Task-specific Liaison Graph (TLG) for each task in the plan. It contains the parts that are already assembled, the applied fixture and the tool as nodes. The edges between the parts are the features directly realized in the previous and in the current assembly steps. Fixturing determines which part (and those already assembled to it) are grasped by the fixture and thus will be the base components, while the other part (and those attached to it) will be the moved components. In the TLG, the fixture node is connected to the grasped part and the tool is connected to the feature's moved part. Since the TLG only contains the directly realized features, it is a tree, and there exists only one path between any two nodes.
The geometric feasibility check of each feature in the macro-level plan is performed in two separate phases (see details in [32,35]): 1. For the local motion defined by the feature, which takes the moved component from its near position to the final relative position w.r.t. the base component. 2. For the approach motion, which brings the moved component from its remote location to the near position.
Since the local motion is perfectly defined by the feature, the colliding pairs of objects (parts, fixture, tool) can be unambiguously identified. Moreover, each colliding pair of objects determines an invalid path in the TLG that connects the nodes corresponding to two objects involved. Then, the generated cut encodes that this invalid path must not reoccur in any macrolevel solution. Namely, in the format specified in 5.2, the preceding feature α is the current feature, the set of succeeding features {β 1 , . . . , β e } is the set

Macro level planning
Path planning Solution? Feasible?
Near positioning DDM evaluation  Fig. 2a during the verification of feature 3. A collision between parts C and D during the local motion results in cut I, stating that feature 3 must precede feature 2, or one of them must be skipped. A collision between part B and tool T1 leads to cut II, with more preceding features and a tool in the cut. The failure of the approach motion results in cut III, which contains all previous features and all the assigned resources.
of features in the invalid path (with the exception of α), whereas the tool γ and the fixture δ are the resources assigned to the current task (only if they take part in the collision).
A similar approach is taken for the verification of the approach motion, with the substantial difference that the existence or the lack of a collision-free approach motion can only be verified by solving a path planning problem. Moreover, the infeasibility of the path planning problem does not lead to a specific collision, and hence, the returned feasibility cut is a generic expression which states that the current task cannot be executed with the same (or larger) set of base and moved components and the same resources. In the generic format of 5.2, α is the current feature, the set {β 1 , . . . , β e } is the set of all features in the TLG (except for α), whereas γ and δ are the assigned resources. Since this cut contains more terms than the cut generated for local motions, it means a substantially weaker constraint on the macro-level plan. The details of the geometric evaluation are discussed in [32,35]. Examples of cuts generated from various micro-level conflicts are shown in Fig. 5.
The micro-level evaluation generates all possible cuts based on the verification of the local motion of all features in the plan, since they can be computed efficiently. In contrast, time consuming path planning is performed for the approach motions only if all local motions in the plan are collision-free, up to the first failure.

Case study and experiments
For evaluating the presented approach, two additional case studies were selected further to that of the working example: an automotive supercharger assembly and a pneumatic cylinder assembly. Fig. 6 shows these assemblies, while problem sizes are summarized in Table 2. The raw number of features and parts reflects the original CAD input, whereas the processed values characterize the model size after merging corresponding parts into composites. It can be noticed that besides the obvious geometric dissimilarities, the three cases differ also in their complexity. The supercharger assembly contains the highest number of parts and edges in the connectivity graph. However, during the analysis and instance definition, most of the connections can be discarded as they do not represent a meaningful feature. Moreover, several features can be grouped together as composites and therefore the resulting number of features from the macro-level perspective is only 17 for 18 parts. This means that every feature has to be assigned in the resulting sequence. In contrast, the ball valve and the cylinder examples have less parts and connections, but the number of features is higher in both cases, meaning that there are alternative ways to realize the assemblies and in the solution not every feature will be assigned to a position in the plan. A part of the fixtures and tools are characterized by geometries as well; collision detection on the micro level is performed only for these resources. Other, special resources, such as a human hand, do not have a solid geometry assigned, and they are disregarded on the micro level.
The CAPP solution loop was implemented using the Python programming language (v3.6) for building up a frame, which calls the macro-level solver developed using the MiniZinc (v2.2.3) constraint modelling language [36] with the Google's OR-Tools [37] open source optimization solver (v7.0, CP-SAT core, with three threads). The experiments were executed in a containerized environment [38] with three CPU cores and 2 GB of memory allocated from a regular computer (2015 Intel i7 processor with 4 cores). The experiments showed that finding an optimal solution is usually quick, however, proving its optimality can take an order of magnitude longer time. In order to control the computational load a time limit of 120 seconds was applied for finding an optimal macro solution per iteration. Since in the solution loop the macro solutions have to be validated on the micro level, it is reasonable to apply this time limit that also reduces the time spent on proving the optimality of solutions, later possibly dropped on the micro level.   It is noted that macro-level planning times displayed in Table2 also include the compilation of the MiniZinc model, and hence, may slightly exceed the specified time limit.
The results of all three case studies are shown in Table 2. Even though the supercharger case study has the highest number of components, this problem instance can be solved relatively quickly, with the lowest number of iterations. The average time to get an optimal macro-level solution here is higher than for the ball valve. In turn, as there are no alternatives for any of the features, the number of iterations (5) and the number of constraints (40) fed back from the micro level is lower. From this aspect the pneumatic cylinder poses the greatest challenge to the solver as there are numerous alternatives for realizing the assembly, which results in the highest number of iterations (16) and constraints (121). The redundancy among features causes a significant increase in the complexity of the macro-level problem, and hence, the planner hits the time limit in each iteration. The experiments also showed that the best solution found by the solver within the time limit has the optimal value, but proving their optimality requires longer search.
With the lowest number of components and features, the ball valve case requires the least time for an optimal macro-level solution. However, due to the alternative features, the number of iterations and constraints generated is higher. Hence, alternative features increase complexity in two different ways: (1) by extending the search space in the macro-level planing problem and (2) by decreasing the efficiency of the feasibility cuts generated in the micro level. The solution to the ball valve assembly is shown as an assembly tree in Fig. 7. The figure tells that the first two steps are completed in the same fixture, which is followed by a fixture changeover (due to weight limit of fixture F1), but from that point onward the fixture remains unchanged (fixture F2). This also suggests that the first two features cannot be done in fixture F2, due to micro-level constraints. The applied tools (T1-"human hand" and T2-"screwdriver") are also shown in the figure, and it can be seen that screwing features are put to the end of the plan in order to avoid unnecessary changeovers.

Conclusions
The paper introduced a constraint model for macro-level assembly planning for two-handed mechanical assembly processes with rigid parts. As a key step in a feature-based iterative assembly planning workflow, macro-level planning performs the selection of assembly tasks, their sequencing, as well as allocating appropriate resources to them, while minimizing the total assembly time.
Beyond enforcing classical macro-level constraints on the assembly plan, the proposed model takes feedback from micro-level validation in the form of feasibility cuts, which provides a means for ensuring, e.g., the geometrical or technological feasibility of the assembly plan on a detailed model of the assembly motions. A new method was proposed to generate cuts based on the results of collision checking, using a novel TLG model, to prevent the reoccurrence of the same collision in subsequent planning iterations. The input of macro-level planning is a feature-based assembly model, partly based on the previous works of the authors. Nevertheless, the current contribution generalizes earlier models in several ways. In particular, it allows an arbitrary liaison graph among the parts, which may involve cycles corresponding to alternative features. Hence, assembly planning also involves the selection the features to be realized directly by the assembly tasks. This, on the one hand, demands less effort during problem definition and, on the other hand, helps avoiding the definition of infeasible problems. On the long term, along with the transition from assembly lines to islands the constraintbased model can be extended towards generating routing alternatives [39], and the planning workflow can accommodate physics-based modelling [40] as well.
The proposed approach was demonstrated on three industrial use cases from different sectors of the industry: a ball valve, an automotive supercharger, and a pneumatic cylinder. The results confirm the generality and practical applicability of the proposed constraint model. The strong expressive power of the CP representation and the efficiency of the solver allows finding exact optimum for real-life examples within acceptable computation time.as well as the efficiency of the constraint-based solution approach.