Exploring Feasible Design Spaces for Heterogeneous Constraints

07/02/2019
by   Amir M. Mirzendehdel, et al.
0

We demonstrate an approach of exploring design spaces to simultaneously satisfy kinematics- and physics-based requirements. We present a classification of constraints and solvers to enable postponing optimization as far down the design workflow as possible. The solvers are organized into two broad classes of design space 'pruning' and 'exploration' by considering the types of constraints they can satisfy. We show that pointwise constraints define feasible design subspaces that can be represented and computed as first-class entities by their maximal feasible elements. The design space is pruned upfront by intersecting maximal elements, without premature optimization. To solve for other constraints, we apply topology optimization (TO), starting from the pruned feasible space. The optimization is steered by a topological sensitivity field (TSF) that measures the global changes in violation of constraints with respect to local topological punctures. The TSF for global objective functions is augmented with TSF for global constraints, and penalized/filtered to incorporate local constraints, including set constraints converted to differentiable (in)equality constraints. We demonstrate application of the proposed workflow to nontrivial examples in design and manufacturing. Among other examples, we show how to explore pruned design spaces via TO to simultaneously satisfy physics-based constraints (e.g., minimize compliance and mass) as well as kinematics-based constraints (e.g., maximize accessibility for machining).

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 5

page 15

page 21

page 23

page 24

page 25

04/25/2021

DC3: A learning method for optimization with hard constraints

Large optimization problems with hard constraints arise in many settings...
12/29/2020

Visualization of topology optimization designs with representative subset selection

An important new trend in additive manufacturing is the use of optimizat...
09/01/2009

Reasoning with Topological and Directional Spatial Information

Current research on qualitative spatial representation and reasoning mai...
03/16/2013

Separating Topology and Geometry in Space Planning

We are dealing with the problem of space layout planning here. We presen...
05/25/2005

Handling equality constraints by adaptive relaxing rule for swarm algorithms

The adaptive constraints relaxing rule for swarm algorithms to handle wi...
11/01/2018

Enhancing the Structural Performance of Additively Manufactured Objects

The ability to accurately quantify the performance an additively manufac...
12/21/2021

Discrete fully probabilistic design: a tool to design control policies from examples

We present a discretized design that expounds an algorithm recently intr...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Mechanical design problems require reasoning about diverse, multiple, and often conflicting objectives and constraints arising from requirements across a product’s lifecycle. The key engineering design challenge lies in traversing the trade space of these requirements to synthesize feasible designs. This challenge has recently been amplified by rapid advances in manufacturing processes. Light-weight, high-performance, and multi-material composite structures with complex geometry and material distribution can now be fabricated using various additive manufacturing (AM) processes. Yet, existing computer-aided design (CAD) systems are far behind in their representations and algorithms to navigate the high-dimensional trade spaces that grow exponentially in the number of available decisions per spatial elements. Additional functional constraints such as manufacturability, ease of assembly, motion in presence of obstacles, and aesthetics dramatically increase the trade space complexity.

Specialized domain-specific computational tools are used to generate designs that satisfy specific types of functional requirements. For example, to maximize a part’s performance with as little cost or material as possible, one may employ topology optimization (TO) tools (1; 2; 3). In most TO approaches, an objective function is defined over a design domain in terms of the physical performance (e.g., strength and/or stiffness) with additional constraints on total mass or volume as well as boundary conditions (e.g., loading and/or restraints) that often account for interfaces with other parts. TO produces valid designs with nonintuitive shapes, topologies, and material distributions that meet physical requirements, but is rarely aware of other important design criteria such as kinematic constraints. On the other hand, to ensure collision-free motion of a part in an assembly, one may need to examine its free configuration space (4; 5; 6) to guarantee collision avoidance. Similarly, for subtractive manufacturing (SM), the machinability of a designed part is predicated on whether the volume to be removed from a raw stock is accessible within the cutting tool assembly’s non-colliding configurations (7; 8). For AM, one may need to consider the part’s morphology, minimum feature size, and skeleton (9; 10; 11; 12) Hybrid manufacturing (combined AM and SM) requires more complicated logical reasoning (13). These problems require nontrivial interference analysis of shapes in relative motion that rely on different tools of reasoning than physics-driven design tools such as TO. The latter often ignore motion related constraints by considering them out-of-scope.

1.1 Kinematic, Physical, & Manufacturing Constraints

Generating practical designs requires simultaneous reasoning about shape, motion, materials, physics, manufacturing, and assembly, among other factors. For example, a machine part that moves relative to other parts in a mechanical device has to avoid collisions with both stationary and moving obstacles (14). These requirements are imposed as kinematic constraints, expressed in terms of pointset containment or non-interference (Section 3.3). The same part has to sustain mechanical loads at its joints or points of contact with other parts. These requirements are imposed as physical constraints, expressed in terms of (in)equalities of mathematical functions that represent physical response (15) (e.g., bounds on deflection or stress). Moreover, the part has to be manufacturable with one or more AM or SM capabilities (13). Manufacturability constraints can be of both kinematic and physical types; for instance, accessibility in SM (7; 8) and post-processing of AM (e.g., support removal (16)) are of predominantly kinematic nature, whereas achieving desired material properties in AM requires in situ physical analysis (17). With few exceptions (e.g., TO for AM with minimized support (18)) TO algorithms are not developed with manufacturability provisions built into their objective functions.

1.2 Generating Feasible Designs with Multiple Solvers

Different computational services, herein called solvers, are used to assist the design process with heterogeneous constraints by providing either analysis tools to evaluate the performance of one or more given designs, or synthesis tools to generate one or more designs that satisfy a given set of performance criteria analysis. We distinguish between these two types of solvers as forward and inverse problem solvers (‘FP/IP-solvers’), respectively (Section 3). Specifically, generative design tools are IP-solvers which solve the inverse problem by systematically generating candidate designs and evaluating their performance (using FP-solvers) to guide refinement of designs until the criteria are met.

It is unlikely that a single IP-solver is capable of simultaneous reasoning about all design criteria (e.g., objective functions and constraints). Therefore, a typical computational design workflow requires carefully organizing and reasoning about several multidisciplinary solvers to address heterogeneous design criteria. While every IP-solver reasoning about a subset of these criteria may produce designs that are feasible (and ideally, optimal) only with respect to the specific criteria it considers, it provides no guarantees about the rest of the criteria. Different IP-solvers are thus likely to generate designs distinct from one another, while none of them simultaneously satisfies all criteria. Except for extremely simple criteria, it appears impossible to combine these solutions in any obvious way that preserves the constraints satisfied separately by each solver, or at least provides the best compromise. Even if such a solution exists, there may not exist any particular ordering of these solvers to find it, simply because each solver performs premature optimization with regard to the subset of criteria it cares about.

Consider the problem of designing a car hood latch (adopted from (14)). An initial design domain with boundary conditions is provided, and the goal is to find a design that is as stiff as possible with the least mass. Moreover, the latch has to be free to rotate clockwise by 20 degrees around a revolute joint, without exiting the initial design domain, so that it would not collide with other parts that are possibly outside that envelope. Functional load-bearing surfaces where the latch mates with other parts are shown in Fig. 1. All feasible designs must retain these surfaces as specified. The said requirements immediately suggest using two IP-solvers that are well-positioned to deal with them (each solver satisfying a subset of them):

  • Let Unsweep (19) be a solver that generates a design that remains within a given region of space while moving according to a prescribed motion (in this case, a clockwise rotation of 21 degrees).

  • Let PareTO (20) be a solver that, starting from an initial design, generates a design on the Pareto front of the two objectives (compliance and mass), i.e., one that satisfies the stiffness requirement and the given boundary conditions with minimal mass.

Figure 1: Functional requirements for designing a car hood latch, including (a) containment under given motion after assembly; and (b) boundary conditions on interfaces for assembly.

Using these solvers separately, one may generate two distinct designs, as illustrated in Fig. 2. However, there is no clear operation with which to combine these two, in order to generate a design that satisfies both kinematics- and physics-based constraints. For example, the intersection of the two designs, shown in Fig. 2 generates a design that does not violate the constraints satisfied by Unsweep, because every subset of the unswept volume also satisfies the containment constraints. However, the constraints satisfied by PareTO are no longer satisfied, because the load paths are changed due to the changed topology and the compliance target is no longer met.

Figure 2: Two partially feasible designs are generated separately by two solvers. Each solver optimizes for a subset of constraints. Arbitrarily combining them (e.g., via set intersection in this example) may result in an infeasible design with respect to all constraints.

In this case, Unsweep has a property that its solution can be interpreted not as a single design, but as a representation of all designs that satisfy the containment constraints. This family of designs is closed under set intersection, i.e., intersecting any of the feasible designs with another set leads to another feasible design. Similarly, PareTO can generate a family of designs that satisfy compliance requirements for different mass budgets. However, this family is not closed under set intersection. The goal of this paper is to show how we can exploit such information to organize the design workflows such that they produce solutions that satisfy all criteria.

It is possible to obtain a feasible solution to the latch design problem by using the same set of IP-solvers, if the workflow is organized differently, as shown in Fig. 3. Suppose we first solve for the containment constraint using Unsweep and generate a valid design that does not exit a given envelope while moving. We can use this design as the initial design input to PareTO and optimize its shape and topology to achieve the compliance target with minimal mass. This approach works because PareTO is a material reducing solver, i.e., its solutions remain strictly contained within the initial design. Hence any design generated downstream will be faithful to the containment constraint that was satisfied upstream. The same argument is not true if the order of applying the solvers is swapped. There is no reason to believe that applying Unsweep to a topologically optimized solution of PareTO will remain on the Pareto front. The fundamental differences between the two IP-solvers should be taken into account when deciding on their arrangement in a workflow—in this case, choosing between parallel or sequential execution and the proper order for the latter. We elaborate on these differences in the classification of solvers in Section 3.

Figure 3: Both constraints can be satisfied by first finding a shape that satisfies the containment constraint and then using this shape as the input to TO (or any other material reducing IP-solver).

Figure 4 shows a one-parametric family of solutions on the Pareto front obtained when using mass and compliance as competing objectives. PareTO provides a clear advantage over classical TO with a single solution, by producing many alternatives some of which might satisfy additional constraints that were not accounted for in TO. This generate-and-test approach is plausible, and in fact, is a common strategy for dealing with heterogeneous constraints. However, it turns out that none of the Pareto-optimized designs in this case will not remain within the envelope after a clockwise rotation of 21 degrees.

In general, a good rule of thumb to organize solvers in a workflow is to call the ones that produce the broadest families of designs earlier. The upstream IP-solvers should generate a large number of designs, as opposed to fixing one or few designs, to provide more flexibility for downstream solvers. The downstream solvers can be FP-solvers, testing for new constraints, or IP-solvers, applying further optimization. However, each solver may prematurely optimize designs that may fail evaluation criteria considered in downstream solvers. The “blind” process of generating and testing designs without carefully considering properties of the workflow – and the associated feasible design space for each solver in the workflow – will scale poorly with increasing number of constraints/solvers and their complexity. A systematic approach to arranging solvers into workflows that guarantees satisfying new constraints without violating the already satisfied constraints is much demanded, and is the subject of this paper.

Figure 4: None of the topologically optimized design alternatives obtained from applying PareTO to the initial design will satisfy the containment constraint. Generate-and-test does not always work.

1.3 Contributions & Outline

The main contributions of this paper are:

  1. classification of IP-solvers based on the properties of design constraints (e.g., locality and continuity) that each solver can handle;

  2. organization of computational design workflows with heterogeneous constraints into two stages of design space ‘pruning’ and ‘exploration’, where pruning provides the feasible design space for exploration;

  3. reconciling set constraints with inequality constraints and deriving conditions under which they can be expressed in a strictly local (i.e., ‘pointwise’) fashion;

  4. pruning design spaces, treated as first-class entities,111

    In the lexicon of programming languages, a construct is said to have first-class status if it can be passed as an argument, returned from a subroutine, or assigned into a variable

    (21). by intersecting their representative maximal elements defined implicitly by pointwise constraints;

  5. strategies to compose FP-solvers into a generative and iterative design process by combining kinematic, manufacturing, and physical constraints; and

  6. illustrating real-world design problems solved using multidisciplinary solvers, which are rarely addressed in the (otherwise siloed) areas of related research.

In Section 2, we review some of the recent works in related areas of computational design and manufacturing.

In Section 3, we present basic definitions (FP/IP-solvers, global vs. local constraints, and design/performance space terminology). We present a classification of solvers based on the types of constraints they can handle, and propose a systematic approach for organizing them into workflows.

In Section 4, we show that an important class of constraints can be satisfied upfront by pruning the design space in the early stages without premature optimization, allowing flexibility for downstream design decisions. The feasible design subspaces are described uniquely and completely by their maximal elements. These representative elements are, in turn, implicitly defined by a point membership classification (PMC) test implemented in terms of strictly local (i.e., ‘pointwise’) constraints. We demonstrate examples of kinematics-based constraints that appear in assembly, packaging, and manufacturing.

In Section 5 we deal with more general global and local constraints, including (in)equality constraints that specify physics-driven requirements or manufacturability.

We use a Pareto-tracing levelset topology optimization (PareTO) (20) which uses fixed-point iteration to satisfy multiple design criteria guided by augmented TSFs. We demonstrate that accessibility constraints can be incorporated in TO by filtering the augmented TSF using the overlap measure of cutting tool and optimized part.

We conclude in Section 6 by a discussion of the limitations of our approach and proposed future directions.

2 Related Work

Real-world design problems often involve solving multi-objective optimization problems where the goal is to find the best trade-off between multiple competing objective functions. Classical methods such as linear programming (e.g., the ‘simplex’ algorithm), nonlinear programming (e.g., the steepest descent and conjugate gradients), or Newton-Raphson

(22) are limited to single-objective optimization problems. Even for single-objective optimization, finding the global optimum is NP-hard (23). Numerous approaches have been developed to converge to locally optimal solutions in reasonable computation time to multi-objective problems across different disciplines.

Unlike single-objective optimization, a total ordering for feasible solutions may not be possible in multi-objective optimization, i.e., there may not exist a single “best” solution due to competing objectives. However, feasible solutions may be partially ordered according to Pareto efficiency—also known as Pareto–Koopmans efficiency or dominance (24; 25). Pareto-optimal solutions are locally optimal (according to Pareto-efficiency) where improving one objective comes at the expense of at least one other objective (26). The collection of all Pareto-optimal solutions is referred to as a Pareto front, which represents a curve, surface, or higher-dimensional manifold in the design space for two, three, or higher number of competing objectives, respectively. Tracing a Pareto front is a key challenge in multi-objective and multi-disciplinary design optimization. We will not attempt an exhaustive review of all approaches such as gradient-free methods including rule-based techniques (27; 28; 29; 30)

and evolutionary algorithms

(31; 32; 33; 34; 35). Rather, we focus on a special class of algorithms that automatically generate designs on the Pareto front of multiple objectives given an initial design.

TO (36; 3; 37) has emerged as a practical class of computational methods for designing high-performance light-weight structures and has been applied in numerous areas such as designing automobiles components (38), aircraft components (39; 40), spacecraft modules (41), cast parts (42), compliant mechanisms (43), and many other products. Numerous approaches such as density-based (44; 45; 46), levelset-based (47; 48), and evolutionary (49; 50; 51) methods for TO have been developed.

2.1 Optimal Design for Manufacturing

TO typically focuses on optimizing designs for performance (e.g., physical response to loads during operation) but less on other important factors such as manufacturability. Apart from traditional processes such as machining and molding, more recent technologies such as AM have introduced the ability to fabricate complex topologically optimized designs while presenting new manufacturing challenges (52). Process limitations must be considered during the design/optimization stage as much as possible to avoid repeated prototyping and iterations until the optimized designs are manufacturable. Specifically, applying corrections to the geometry (9) or topology (11) of a solution after TO to make it manufacturable may sacrifice the achieved optimality.

One solution is to impose design rules obtained from domain expertise and experience. These rules relate specific combinations of shape, materials, and process to impose simplified constraints that can be built into the TO framework to restrict the feasible design space. For example, when designing for AM via fused deposition modeling using polymers, one should require that all facets oriented at an angle greater than 45 degrees with respect to the build direction be supported with additional scaffolding material. When designing for casting and injection molding processes, one should ensure that the part has features of almost uniform thickness and no entrapped holes are present, so that the mold can be removed and the molten material cools down uniformly throughout the part (53; 54). When designing for wire- or laser-cutting, one should ensure that the final design has a uniform cross-section, i.e., is 2.5D along the cutting direction. These constraints can be imposed during TO through filtering of the sensitivity field as illustrated in Fig. 5.

Figure 5: Examples of enforcing manufacturability constraints by TSF filtering. Different filters (c, e, g) – plotted along the cross-sections shown on the right – produce different solutions (d, f, h).

Another important AM consideration is the manufacturing resolution, which can be directly incorporated into the TO algorithm as a minimum feature size constraint through either local gradient constraints (55) or TSF filtering (43) (Fig. 6). It is also possible to reduce the amount of support structure needed in an AM by either finding a good build orientation or TSF filtering. Build orientation optimization often involves solving a multi-objective problem taking into account other factors such as surface quality (56; 57), build time (56), or manufacturing error (58). TSF filtering, on the other hand, can be achieved by penalizing overhang surfaces (59; 60), penalizing undercut surfaces (61), or augmenting new TSFs (18).

Figure 6: Constraining minimum feature size via TSF filtering (62).

Other AM constraints may not be as straightforward. For instance, optimizing designs with respect to shrinkage and warpage during material phase changes within the AM process may require solving a multi-physics problem at every iteration (17; 63). Characterizing material properties of AM parts is also challenging due to process-induced anisotropy. Lack of inter-layer adhesion and varying thermal history at every point can introduce unintended porosities and consequently affect material behavior. Although there are initial results for considering anisotropy in TO under certain assumptions (64), solving the problem by simultaneously optimizing the geometry, topology, and process parameters involves costly in-situ manufacturing simulation or process planning (7; 13).

Figure 7: Solving heterogeneous (e.g., kinematic, physical, and manufacturing) constraints with multidisciplinary solvers is difficult. Each solver might make decisions with care for its target subset of constraints while potentially violating the rest of the constraints. (a) Arranging multiple solvers sequentially may work in some orders and fail in others, depending on what properties they preserve. Parallel composition requires combining solutions in ways that do not always preserve the properties either. (b) We propose a systematic two-phase approach (Section 3.4) to design space pruning (Section 4) and design space exploration (Section 5). The former invokes IP-solvers in an arbitrary order to cut out the infeasible design subspace without premature optimization. The latter navigates the pruned design space by fixed-point iterations over FP-solvers. Section 3 addresses the question of how to divide a given collection of solvers into these two groups.

2.2 Design for Motion-Related Constraints

In addition to the above examples of performance and manufacturing requirements, there are other important design criteria that involve spatial reasoning about the interactions of moving (translating and rotating) shapes such as collision avoidance, packaging, robot motion planning, and accessibility analysis. These requirements cannot be easily enforced by design rules, TSF filtering, or other techniques commonly used in TO. Rather, they are often expressed as set constraints, i.e., statements in the language of sets (e.g., in terms of affine transformations, Boolean operations, and containment) rather than the language of real-valued functions used for (in)equality constraints in TO. A broad class of inverse problems in practical design and manufacturing reduce to solving set constraints formulated in the configuration space of rigid motions (6; 65; 66; 67).

Although the problems with set constraints are common and of significant importance, they are not mainstream in design/optimization workflows due to non-smoothness and computational intensity (68). There are instances of TO frameworks that deal with motion-related problems in an ad hoc manner; for instance, in modeling collision and contact when designing compliant mechanisms (69) or parts made of hyperelastic materials that undergo large deformations part (70; 71). However, it is not immediately obvious how set constraints can be incorporated in a systematic fashion into the design/optimization process without incurring prohibitive computation costs of spatial analysis at every iteration. The next section presents a different classification of constraints that enables design space pruning and exploration, in which set constraints are also restated in terms of (in)equalities of functions.

3 Classifying Solvers and Constraints

In this paper we restrict our attention on solvers that reduce material from a bounded domain in 2D and 3D space to generate designs. Our focus will be on the properties of constraints embedded within computational solvers to reason about their ordering in the workflows.

When all objectives and constraints cannot be handled by a single solver, current practice relies on a case-by-case domain-specific analysis to properly construct workflows. Figure 7 (a) depicts examples of combining Unsweep and PareTO illustrated in Section 1.2. An arrangement that works in one case may not work in another.

In contrast, we present a systematic approach for organizing solvers into workflows by first classifying solvers into two fundamentally different types:

  1. Design space pruning solvers restrict the feasible design space by pruning the subspaces that violate one or more design criteria. They are permutative, meaning that they can be called at the beginning of the design workflow in an arbitrary order. By directly operating on the design subspaces as first-class entities, they postpone optimization to downstream solvers.

  2. Design space exploration solvers simultaneously explore the (pruned) design subspaces for optimized solutions. In this paper, we choose a well-studied Pareto front tracing approach (PareTO) (72) to efficiently navigate the trade space of multiple objectives.

Figure 7 (b) illustrates the framework. In this section we present some terminology and a classification of design criteria based on which the solvers can be grouped into the above two classes. We formalize this two-phase approach in Section 3.4 and discuss how to implement each phase in depth with examples in Sections 4 and 5, respectively.

3.1 Design & Performance Spaces

Figure 8: (a) FP-solvers (e.g., FEA and manufacturability analysis) map an instance of the design space (i.e., a “design”) to an instance of the performance space (i.e., a “field-tuple”). Predicates are defined to decide whether the design is satisfactory with respect to constraints in terms of performance variables. An IP-solver modifies the design until all constraints are satisfied.

Throughout this paper, a ‘design’ refers to a computational model of a single designed artifact. We begin the process by specifying a bounded design domain ( or ) whose corresponding design space is the collection of all ‘solids’, i.e., closed-regular semianalytic pointsets in space,222A closed-regular set is defined as a set that equals the closure of its interior (i.e., is homogeneously 3D) (73). contained within the design domain. We use the notation (read: “solid powerset” of ). This definition is sufficient for geometric modeling of parts with homogeneous and isotropic material properties. We initially restrict our attention to this subclass of artifacts, as considered in classical solid modeling (73). Our goal is to first illustrate nontrivial challenges in designing with multiple solvers before introducing the additional complexity of multiple materials, heterogeneity, or anisotropy. However, the concepts introduced hereafter can (in principle) be generalized beyond solids.

The ‘performance’ of a given design is an tuple . Think of the performance space as a product space , where each is a class of fields, i.e., each is an integrable field over the design domain whose value at a given “query point” is denoted by . Examples of such fields are:

  • binary-valued fields (), used to describe indicator functions of regions of interest within the design domain such as non-manufacturable features (7; 8) or regions requiring design correction (9).

  • integer-valued scalar fields (), used to characterize local topological properties of 3D printed parts (11; 12) or to classify atomic units of manufacturing in hybrid (combined AM and SM) manufacturing (13).

  • real-valued scalar fields (

    ), 3D vector fields (

    ), and higher-rank tensor fields used to represent distributed physical quantities such as displacement, velocity, stress, strain, and so on

    (15), or manufacturability measures (10).

3.1.1 Forward Problem in Physics & Kinematics

Forward problem solvers (FP-solvers) map a given design instance to one or more performance fields, hence can be viewed as implementations of one or more maps . The entire forward problem, solved by one or more FP-solvers, can be viewed as a single map from design space to performance space , which has a unique outcome for a given design.

For example, consider a finite elements analysis (FEA) FP-solver that computes (discretized forms of) a displacement field for small deformations (15) of a given design due to boundary conditions such as restraints and external forces (Fig. 8). It is also important to compute the stress field , which depends locally on displacement and material properties (e.g., the linear elasticity law). The vector/tensor values of solution fields probed at a query point are denoted by and . In this case, both functions are zero outside the design, i.e., if . FEA solves the weak form of the governing differential equation, discretized into a linear system (e.g., using hat functions) , where the stiffness matrix and external load vector depend on the design shape and material properties, as well as boundary conditions. The equations are solved to obtain the discrete form of the displacement field from which the discrete form of the stress field is computed by linear operations.

Another example is accessibility analysis for machining (e.g., milling or turning) (7; 13). For instance, consider an FP-solver for axis milling simulation, which computes (discretized forms of) a volumetric measure of inaccessibility as a field for a given design and machine tool parameters. This measure at a query point , denoted by , returns the penetration volume of the moving tool assembly , including the holder and cutter , into the stationary obstacles , including target form and fixtures . The solver computes the discrete form of this field (e.g., sampled at point clouds or voxels) as a convolution between the discrete forms of the indicator functions of stationary solids and moving solids

using a fast Fourier transform (FFT)

(74). The maximal set of accessible configurations – in this case, pure translations in 3D for a fixed orientation – is then obtained as the null set , i.e., the translations that do not lead to undesirable collisions. The maximal removable volume is obtained by sweeping the cutter with the maximal motion, i.e., . Its indicator function can be viewed as a predicate for accessibility, i.e., it returns 1 (resp. 0) if the query point is (resp. is not) accessible. The discrete form of this binary field can also be obtained by thresholding FFT-based convolution of discrete forms and .

The computations performed by the above two FP-solvers (FEA and accessibility analysis) are abstracted by that maps a given design to a “field tuple” that represents analysis results. Figure 8 illustrates one instance of each such field for a topologically optimized bracket—solution of a DARPA design challenge problem for TRAnsformative DESign (TRADES) program.

3.1.2 Feasible Design Subspaces & Predicates

Inverse problem solvers (IP-solvers), on the other hand, find one or more designs that satisfy a given collection of functional requirements. Most IP-solvers employ an iterative process to:

  1. generate one or more valid candidate design(s);

  2. perform analysis on the candidate design(s) to compute the performance(s) of interest (using one or more FP-solver(s));

  3. evaluate the performance(s) against given functional requirements; and,

  4. if the requirements are not met, decide on the next generation of candidate design(s) based on the current evaluation and update rules.

The process is repeated until the requirements are met. The evaluation process (item 3) can be conceptualized as finite number of predicates defined over the performance space as for . Each predicate’s outcome is determined by means of a constraint imposed on the performance field simulated by an FP-solver:333Without loss of generality, we assume that every requirement depends on one performance field only. If more than one field is used in calculating a predicate, we tuple those fields into another field. If more than one requirement is computed on one field, we think of it as two copies of the same field.

(1)

These can be (in)equality constraints (Sections 3.2), which are common in physics-based design formulations as in TO, and set constraints (Section 3.3), which are ubiquitous in design under kinematics-based constraints such as packaging, assembly, and accessibility for manufacturing.

We can think of the performance criteria evaluation as a map i.e., is a binary string whose bits indicate whether a given design satisfies each of the criteria (Fig. 8). A design is called ‘feasible’ if it simultaneously satisfies all criteria, i.e., . The feasible design subspace is the subset of all feasible designs, defined as:

(2)

Here, denotes inversion of a mathematical relation.444Given , we define . Note that in general, is a set, i.e., . It is a singleton set (i.e., has one element) if the function is bijective.

Unlike forward problems, inverse problems have non-unique, often infinitely many, solutions (i.e., ). The feasible design space can also be defined as the intersection of the feasibility halfspaces , each implicitly describing one of the design subspaces that satisfy one criterion at-a-time:

(3)

The idea of design space pruning (Section 4) is to progressively cut out portions of the design space that violate any one of the criteria. Theoretically, pruning can be done in an arbitrary order—noting that intersections or unions of the halfspace in (3) are permutative. Computationally, however, it is only possible if the design subspaces can be manipulated by algorithms as first-class entities. Our goal is to understand under what conditions such manipulations are possible and how an entire design subspace can be represented. The existence (Proposition 1) and completeness (Proposition 2) of such representations are discussed in Section 4.

3.2 Global, Local, & Strictly Local Inequality Constraints

The predicates introduced earlier are implemented in practice by testing whether a candidate design’s performance satisfies an (in)equality constraint.555Note that every equality constraint can be represented by two inequality constraints and . We classify such constraints into three types; namely, global, local, and strictly local (in)equality constraints.

3.2.1 Global Inequality Constraints

It is common to have design criteria specified in terms of global constraints , i.e., by defining a predicate of the general form:

(4)

in which is a function of the entire shape of the design , potentially in addition to fixed external factors such as boundary conditions, manufacturing process parameters, packaging envelope, operating conditions (e.g., motion in assembly), etc. The constraint is often evaluated in terms of a global property of an entire performance field , e.g., as an upper/lower-bound on its maximum/minimum or its integral properties such as norms. This is denoted by where . For example, one can constrain the maximal displacement or maximal stress of a solid under external loads (Fig. 8) by using the following constraints in (4):

(5)
(6)

where are constant upper-bounds on the magnitude of the displacement vector and stress tensor, captured by the constraints and , respectively. One can in general use the norm of the fields for finite (but large) , noting that maximum is a special case as . This is especially useful to smooth out the possible singularities (e.g., infinite stress, due to stress concentrations).

Here is another example to constrain a design to be manufacturable via machining, using the accessibility analysis mentioned earlier:

(7)

where is a negation. This constraint restricts the total volume of inaccessible regions , obtained as the norm of their indicator function, by an upper-bound .

3.2.2 Local Inequality Constraints

It is sometimes possible to define a predicate in terms of local constraints evaluated at a specific point in the design domain; for instance, using one of the following forms:

(8)
(9)

Note that the two alternative forms are different by the “for all” and “there exists” quantifiers, which lead to different global implications. Unlike the case with (4), here is field for a fixed design , i.e., is also a function of the query point . In turn, the constraint is evaluated based on the probed value of the performance field (generally, a tensor) at the query point. We denote this dependency by where . For example, the global displacement and stress bounds mentioned earlier can be imposed locally (Fig. 8):

(10)
(11)

It is easy to verify that using (10) and (11) with (8) is equivalent to using (5) and (6) with (4) in this example. In general, local constraints used with “for all” or “there exists” quantifiers in (8) and (9) can be equivalently expressed as global constraints (stated independently of ) via min/max, respectively:

(12)
(13)

As another example, consider the accessibility analysis discussed earlier. Instead of constraining the total volume of inaccessible regions via the global constraint of (7), we can locally constrain the inaccessibility measure as:

(14)

where and are the stationary and moving solids, respectively. is a small constant to provide allowance for numerical errors. The convolution operator is defined as:

(15)

where is a reflection with respect to the origin, hence is the indicator function of the moving object (i.e., tool assembly), translated to the query point . The integral is nonzero at integration points that belongs to the interference of the translated object with the stationary obstacles.

It is not always possible to convert global constraints to local constraints or vice versa, without defining new performance variables, e.g., in terms of the norms of existing performance fields. We show in the next section that when is decidable independently of , the above two constraints lead to maximal/minimal feasible designs (in set-theoretic terms).

3.2.3 Strictly Local Inequality Constraints

An important special case of (8) occurs if the predicate is decidable without a priori knowledge of the design itself. In other words, the constraints can be evaluated purely from a knowledge of the query point’s position and external factors, if any (e.g., a known rigid body motion applied to the entire design). The predicate’s result can be obtained without knowing the overall shape of the design. This is the case if , i.e., the forward problem’s solution can be evaluated pointwise—emphasized by the overline notation. The corresponding constraint is hereafter called a strictly local (i.e., pointwise) constraint. The predicates in (8) or (9) in this case are dependent on only due to the logical quantifiers for the pointwise testing:

(16)
(17)

Hence, one can define pointwise predicates in this case:

(18)

We show in Section 4 that the pointwise predicate defines a point membership classification (PMC) that implicitly determines the entire feasibility halfspace using its “representative” maximal/minimal feasible design using (16) or (17), respectively. In this paper, we restrict our attention to the former (“for all” quantifier and maximal designs), since it lends itself to material reducing downstream solvers such as TO.

The physics-based constraints exemplified earlier might reduce to pointwise constraints in rare examples—e.g., the stress tensor for hydrostatic pressure in a liquid container at rest depends on the query point’s depth from the surface, but not on the container’s designed shape. Nevertheless, pointwise constraints are ubiquitous in kinematics-based constraints that are central to applications ranging from assembly and packaging to manufacturing. In the next section, we present an important subclass of pointwise constraints that manifest as set constraints.

3.3 Converting Set Constraints to Inequality Constraints

Many kinematics-based design criteria lead to constraints expressed in the algebra of sets. A common form of set constraints is in terms of containment: (for a fixed envelope ). The exact same constraint can be written in terms of non-interference: (for a fixed obstacle ), where is a set transformation and (i.e., complement of ).

At a first glance, these constraints appear to have a completely different form than the inequality constraints described in Section 3.2 in the algebra of fields. Here, we show that set constraints can always be reformulated as (global or local) inequality constraints by virtue of describing sets with their indicator functions. However, converting them to strictly local (i.e., pointwise) constraints is possible under certain conditions.

3.3.1 Global or Local Set Constraints

For every solid

, its indicator (i.e., characteristic) function

is defined as:

(19)

Hence, every containment constraint is restated as an inequality constraint of the form used in (8):

(20)

i.e., using the standard form .

Recall from Section 3.2 that the above inequality constraint can also be rewritten as a global constraint of the form used in (4) by upper-bounding the maximum:

(21)

Notice that we have not made any assumption on the properties of the pointsets . In most practical scenarios, both are solids within a bounded domain, taken as the design domain . In such cases, the properties of the mapping and envelope can be exploited to compute the maximum in (21) efficiently.

Moreover, if the set constraint is in terms of regularized intersection, it can be rewritten as a global (in)equality constraint in terms of the volume (or , for consistency), which, in turn, is an inner product of indicator functions:

(22)
(23)

Further, if is a rigid transformation of , the inner product turns into a convolution of and over the configuration space of motions (65).

Let us consider the inaccessibility analysis one more time. For manufacturing with precision requirements (e.g., for assembly/fit), we can restrict the inaccessible regions to be completely contained within a tolerance zone , hence formulating the problem as a set constraint , where:

(24)

For translational motions , the sweep in (24) can be simplified into a Minkowski sum:

(25)

The maximal collision-free motion (7) is obtained as the complement of the space obstacle, which is in turn computed by Minkowski operations (for translational full-dimensional motions):666The operators are all regularized to ensure their algebraic closure within the design space (75). The caveat is that collision-free lower-dimensional motions (e.g., of a peg inside a hole with no clearance) would be pruned from collision-free motions.

(26)
(27)

where represents the tool assembly, including the holder and the cutter . It is understood that Minkowski sums in (26) can be obtained from the 0-superlevel set of the convolution fields of the participating sets (65).777In general, (65). More precisely:

(28)

where is the convolution operator in and (resp. 0) if (resp. ) is the sign function. The latter is needed to convert the real-valued convolutions to binary-valued indicator functions. See (65) for a proof.

In summary, set constraints, as defined in this section in terms of containment or non-interference, can always be restated as global or local inequality constraints defined in Section 3.2. In the next section, we show the conditions under which set constraints can be converted to strictly local (i.e., pointwise) constraints, to enable design space pruning in Section 4.

3.3.2 Set Constraints as Pointwise Constraints

Depending on the properties of , the inequality constraint , used in global or local forms of (20) and (21), respectively, may or may not be restated as a strictly local (i.e., pointwise) constraint. Our goal in this section is to articulate the conditions under which this is possible.

To enable pointwise formulation, we need to eliminate the dependency of the PMC for on so that on the left-hand side of the inequality constraint in (20) depends only on the query point and the fixed envelope . This can be done if the set transformation is itself a pointwise transformation, meaning that it can be defined by extending a transformation of 3D points to a transformation of 3D pointsets by simply applying the former to every point of the pointset and unifying the results:

(29)

Note that is itself a pointset, not a point, to capture the most general case. For example, it can be a curve segment or surface patch representing the 1D or 2D trajectory of a point under a given one- or two-parametric motion, respectively.

The above refactoring is possible for many important applications. For example, if the design has to move (when deployed in assembly) according to a known motion set without exiting a safe region of space that contains no obstacles (14), the above constraint can be used with , where

(30)

is the sweep of the designed part as it travels by the given motion (known a priori). In this case the sweep indicator function can be directly obtained as follows:

(31)

In other words, a PMC test for can be obtained by applying the inverse motion to the query point and checking if it intersects the design. The inequality constraint in (21) can thus be computed rapidly by sampling query points in the design domain and testing intersections of their inverse trajectories with the design (14). Importantly, the computation for one point does not need one to have explicit knowledge of the results for other points. Other than perfect parallelization (e.g., on GPU), this property enables pruning the design space – leading to development of the Unsweep solver discussed earlier – before optimizing the design for other criteria.

In general, for pointwise transformations as in (29), the global constraint can be restated as:

(32)

i.e., remains within after a transform iff all points inside it remain within after a transform. Note also that inequality constraint in (20) can now be rewritten in a pointwise fashion every :

(33)

As with other inequality constraints, not every global or local set constraint can be converted to a pointwise set constraint. For example, the toleranced accessibility constraints for in (24) cannot be evaluated pointwise, because the maximal collision-free motion depends on the global shape of , unlike the case with the fixed motion in the earlier example with Unsweep.

3.4 Design for Heterogeneous Constraints

We conclude this section by a fairly general formulation of a design problem subject to heterogeneous (e.g., kinematics- and physics-based) constraints.

Without loss of generality, let where are the number of global, local, and strictly local (i.e., pointwise) constraints, respectively. All constraints, including set constraints, are expressed as inequality constraints for uniformity. The design problem is to identify the feasible design space , stated as a constraint satisfaction problem:

(34)

We assume that none of the can be simplified into one of or forms. Hereafter, we use the P-, G-, and L-subscripts for various notions related to pointwise, global, and local constraints, respectively; for instance, where is the design subspace that is feasible with respect to pointwise constraint alone, and so on. We solve the design problem in two phases, depicted in Fig. 7 (b):

Phase 1

Prune the design space from to , i.e., solve the following (simpler) problem:

(35)

In Section 4, we solve the above problem by computing a maximal set in the partial ordering of designs via set containment.

Unfortunately, this is not possible for and . In most cases, one can at best generate a finite sample of feasible designs that are superior in some way.

Phase 2

Explore the pruned design space to find a sample of (locally) “Pareto-dominant” (24; 25) designs that satisfy the remaining constraints:

(36)

Pareto-dominance of means that for some neighborhood and in the pruned design space,888Technically, is an open set in the induced Hausdorff topology of (all solid subsets of the maximal element). within which no other design is superior to with respect to all objective functions . We can pose this as a minimization problem:

(37)

The objective functions define another partial ordering over the pruned design space, whose maximal elements we seek, i.e., .

In Section 5, we solve the above problem by iterative optimization guided by TSF. The TSF is defined with respect to global objective functions and global constraints and is penalized/filtered using local constraints . Since global optimization () is NP-hard (23), we settle for local optimality.

4 Design Space Pruning

In this section, we present a methodology to solve the phase 1 problem formulated in (35) of Section 3.4. Using the terminology and results of Section 3, we show how the design space can be pruned with respect to pointwise constraints (including set constraints) without premature optimization. We illustrate the process using examples from kinematics-based constraints that are common in assembly, packaging, and manufacturing.

4.1 Existence & Completeness of Maximal Designs

The following results on the existence and uniqueness of maximal pointsets and their informational completeness as a representation for entire feasible design spaces are central to design space pruning.

Proposition 0.

(Existence and Uniqueness) For every strictly local (i.e., pointwise) constraint , its feasibility halfspace has a maximal element , defined implicitly by the following PMC test:

(38)
(39)

The maximality is in terms of set containment, i.e., every satisfactory design is contained in the maximal element: .

Proposition 0.

(Completeness) For every strictly local (i.e., pointwise) constraint , its feasibility halfspace contains every solid , i.e., every solid subset of the maximal element is also feasible: .

In terms of predicates, the design subspace (which satisfies (16)) can now be represented by a single design (whose all points satisfy (18)). The maximal solid is thus a complete representation of the feasibility halfspace as the collection of all of its solid subsets denoted by .

Here is an intuitive but simplified reasoning:

  1. The set defined by (38) or (39) contains all points that satisfy the constraints.

  2. Every solid subset of the maximal set satisfies the constraint, because all of its points satisfy the constraint independently of the global shape.

  3. Conversely, every feasible solid is the subset of , because it only includes points that satisfy this constraint independently of the global shape.

Note that the constraint’s independence of the shape of is crucial for this to hold. For global or local constraints with dependency on itself, attempting to write a PMC similar to (38) leads to a circular definition where the right-hand side depends on the set itself. For example, the (global or local) constraints given in Sections 3.2.1 and 3.2.2 on FEA and printability analyses do not lead to maximal elements because their constraints depend on particular design instances. It does make sense to define the maximal set of a feasible space (e.g., using the set-builder definition in (39)) in a way that it depends on a particular instance of that space. On the other hand, the set constraints of Section 3.3.2, such as containment under a prescribed motion, do give rise to maximal elements, as we elaborate with examples in the following sections.

The above reasoning does not take topological regularization into account—there is no reason for a maximal set obtained via (38) or (39) to be a solid, hence it may not itself be a valid design. However, we show that there always exists a valid maximal element obtained by regularizing (38) or (39). The correct definition is:

(40)

where and are the topological closure and interior operators, respectively.

Proposition 0.

(Design Space Pruning) Given a number of pointwise constraints for , the feasible design space , defined by intersecting all feasibility halfspaces , has a maximal element that satisfies the uniqueness and completeness properties, i.e., . It can be obtained by intersecting all maximal elements :

(41)

in which the intersection/conjunction operators need to be regularized.

To see why this is true, note that any query point’s membership in an (unknown) feasible design can be tested against all constraints independently of other points’ membership. If for , the point can (but does not have to) be included in the design, for it to be feasible. The feasible design is hence a subset of all points that satisfy all pointwise constraints.

The above result enables computing on design subspaces as first-class objects. Computationally, the feasibility halfspaces are represented uniquely by their maximal elements. The pruning of halfspaces (abstract operation) is implemented by intersecting maximal elements, i.e., conjuncting point membership tests defined by pointwise constraints (concrete algorithm) in an arbitrary order.

(42)

Figure 9 illustrates design space pruning via (3).

Figure 9: Design space pruning can be abstracted by intersecting the design space with feasibility halfspaces. This is not a computable operation in general. However, for pointwise constraints, it can be computed by intersecting maximal elements in the physical space.

Next, we consider maximal elements for set constraints in Section 4.2, and provide examples from real-world engineering problems in Section 4.3, 4.4, and 4.5.

4.2 Maximal Pointsets for Set Constraints

Many design requirements, especially those that relate the interaction of moving shapes, may be expressed as set constraints of the form , where is a set transformation. For example,

  • In packaging and assembly problems, the part’s shape is often designed so that it is restricted to remain within a specified envelope while moving according to a prescribed motion.

  • When designing part to be machined using a given tool that moves in the presence of obstacles (e.g., the part itself and fixtures), the surface of the part has to be accessible without collisions with the obstacles.

We will address examples of these problems in the following sections. The common theme to many motion-based set transformation is that they can re-factored via (29) via a pointwise transformation that depends on the motion. The maximal pointset that satisfies the containment or non-interference test is defined implicitly by its PMC given in terms of :

(43)
(44)
(45)

where the set operators are regularized, as before. Note that may not be a function, because is not necessarily invertible (see footnote 4).

Here are a few classical examples from solid modeling:

  • For one-parametric sweep , one has where is a continuous one-parametric set of motions for . The maximal shape that satisfies is given by an unsweep (19).

  • For Minkowski sum , one has where is typically a solid. The maximal shape that satisfies is given by a Minkowski difference with (76).

  • For general dilation (which subsumes the above two) with general rigid motions, the maximal shape is given by general erosion (77).

  • For non-rigid (but pointwise pre-determined) deformations, the maximal shape is obtained by its PMC in terms of the pointwise displacement function.

Procedure

Propositions 1 through 41 suggest a systematic procedure to prune the design space, i.e., reduce the design space to for kinematic criteria expressed in terms of pointwise set constraints:

  • Step 0. Initialize the feasible design space with the design domain, i.e., in algorithmic terms, .

  • Step 1. Express the set constraint that outlines one of the conditions for a given design to be feasible in the form . Check if it can be restated as a pointwise constraint as in (32).

  • Step 2. Formalize the forward problem in terms of the PMC test for the maximal element obtained from the pointwise constraint as prescribed by (43).

  • Step 3. Invoke an IP-solver for the inverse problem, which computes (an exact or approximate representation of) the maximal element in (44).

  • Step 4. Prune the design space by intersecting the maximal element obtained so far the new , i.e., is a smaller maximal element representing a pruned feasible subspace.

  • Repeat steps 1–4 for all pointwise set constraints.

Notice that the above procedure can be applied to different constraints via independent invocation of IP-solvers in an arbitrary order.

Importantly, the IP-solver in step 3 can be implemented in two fundamentally different ways to obtain either an implicit representation (i.e., using PMC test in (43)) or an explicit representation (i.e., using inversion in (45)) of the maximal element:

  • If we have access to an IP-solver that computes an explicit representation (e.g., B-rep) of the inverse transformation , we can directly intersect it (using any CAD kernel) with the design domain to obtain the maximal element as prescribed by (45).

  • If we have access to a FP-solver that computes (explicitly or implicitly) the forward transformation for a given query point , we can compute an approximate representation (e.g., point cloud or voxelization) of the maximal element by:

    1. sampling the design domain with a sufficiently dense set of query points;

    2. invoking the FP-solver to PMC-test them using (45); keep the ones that pass the test and discard the ones that do not; and

    3. (optional) use adaptive local re-sampling around the points that passed the test to obtain a better approximation.

    Because of the independence of pointwise test, invocation of the FP-solver for different query points can be done with perfect parallelization.

Let us apply this procedure to a few examples.

4.3 Pruning for Containment of Moving Parts

Consider the latch design problem introduced earlier in Section 1.2, where the goal is to design a car hood latch that remains within an envelope while moving according to a motion .

Step 1

Every feasible latch design must satisfy the set constraint where ; i.e., the swept volume by the latch after being transformed by all configurations (including any combination of translations and rotations, parameterized or otherwise) remains within the envelope. The sweep is a pointwise transformation, i.e., can be computed as the union of all , which represents the trajectory traced by the query point along the prescribed motion. Hence, the containment constraint be tested in a pointwise fashion by .

Step 2

Using the definitions in (43), we construct a PMC test for the maximal shape in the design space that satisfies this pointwise constraint:

(46)

The forward problem involves following the trajectory, either exactly or approximately (e.g., by sampling), and testing whether it remains entirely within the envelope.

Step 3

The dual properties of the FP- and IP-solvers (i.e., Sweep and Unsweep) (19) can be leveraged to construct an exact or approximate representation of , as illustrated in Fig. 10. If we have access to an Unsweep solver, we can directly compute . However, if we only have access to an efficient Sweep solver, we can still compute an approximate representation of using the PMC test in (46) for a sufficiently dense sample of query points and retaining the points whose forward trajectory remains within the envelope (14):

(47)
(48)

The invertibility of rigid transformations is key to efficient direct implementation of Unsweep.

Figure 10: is the largest set that remains within the square envelope shown in (a) while moving by a clockwise rotation around a fixed pivot (14), i.e., without violating the containment constraint as depicted in red in (b). The unsweep can be computed in general by intersecting all moved instances of the envelope with an inverse motion (19).

The remaining steps 4 and 5 are straightforward.

can be sent as the initial design to design space exploration (Section 5) via TO or any other downstream material reducing IP-solver. It is guaranteed that every valid design that is the output of the downstream IP-solver, no matter how complicated, will continue to satisfy the set constraint .

4.4 Pruning for Accessibility with Obstacles

Figure 11: (a) A machining setup showing six clamps used to locate and hold a designed part, and a axis instrument that can move in the plane. The envelope within which the shape must be designed is also highlighted. (b) The convolution of the reflected head with the fixtures gives a 3D field whose 2D cross-section via the plane of motion captures the collision volume at different translations. The position with zero collision volume (dark blue) are accessible. (c) The 2D cross-section of the 2.5D maximal manufacturable shape is obtained as the zero-set of the convolution field. This pointset serves as the initial design for TO (Section 5).

Consider another example in a very different setting. Suppose we are designing a part that needs to be fixtured in a crowded workholding environment so that a machining instrument is able to access specific locations without colliding with surrounding fixtures.

For simplicity, assume that the raw stock is a thick sheet of metal, fixtured on the machine bench as illustrated in Fig. 11 (a). The manufacturing process is an EDM wire-cut or CO laser-cut in which the tool assembly moves according to a planar (i.e., 2D) motion parallel to the workpiece. We assume that the translation with a vector brings the wire or laser beam, abstracted by a vertical line of zero thickness , in contact with a line segment with for a range of values along the sheet thickness.

The head cannot collide with the workpiece because they are located at different elevations, i.e., is a priori guaranteed, thus imposes no constraint. Nonetheless, the head may collide with the fixtures , which may extend above the workpiece, i.e., imposes a constraint on the motion. This, in turn, imposes a constraint for manufacturability, because the motion defines the boundary of the cut shape, restricted to a curve on the 2D plane: . In other words, designing the as-manufactured part’s shape amounts to designing the motion, because every translation of the wire or laser beam is in one-to-one correspondence with a point on the part’s boundary at which there is no collision between the head and the fixtures.

Step 1

The moving head may not collide with the fixtures when swept under the motion , i.e., , i.e., . This is written in the standard form . Equivalently, for all translations we have , i.e., which is in pointwise form for . Notice that does not depend on , as required.

Step 2

Using the definitions in (43), we construct a PMC test for the maximal shape in the design space that satisfies this pointwise constraint:

(49)

It is important to note that our success in defining a pointwise constraint (hence a PMC) depended on the assumption of planar translation at a higher elevation than the part, which guaranteed . Otherwise, the correct constraint in (49) would have instead of on the right-hand side, making it stricter. But we cannot define the maximal element and its corresponding feasibility halfspace in terms of a particular instance (circular definition).

Step 3

Once again, we can leverage the dual properties of the FP- and IP-solvers to compute an explicit or implicit representation of the 2.5D maximal manufacturable solid.

The FP-solver can be any collision detection algorithm between arbitrary solids, taking as input the displaced head above a particular query point and the stationary fixtures . Therefore, one can sample the design domain (i.e., the raw stock) over a 2D grid and construct a bitmap image, representing the 2D section of the 2.5D maximal solid, by testing (49) for all . Every test requires invoking the collision detection algorithm, and can be done in parallel.

Alternatively, one can construct an IP-solver to compute the collection of all collision-free 2D translations (i.e., the configuration space obstacle (5)). Since we are dealing with solids and regularized intersections, we can rewrite the set constraint in terms of measures and convert it to an (in)equality constraint via (23). Hence, (49) becomes:

(50)