Abstract

This study introduces a novel methodology for vehicle development under crashworthiness constraints. We propose coupling the solution space method (SSM) with active learning reliability (ALR) to map global requirements, i.e., safety requirements on the whole vehicle, to the design parameters associated with a component. To this purpose, we use a classifier to distinguish between the design that fulfills the requirements, the safe domain, and those that do not, the failure domain. This classifier is trained on finite element simulations, exploiting the learning strategies used by ALR to efficiently and precisely identify the border between the two domains and the information provided on these domains by the SSM. We then provide an exemplary application where the efficiency of the method is shown: the safe domain is identified with 270 samples and an average total error of 2.5%. The methodology we propose here is an efficient method to identify safe designs at a comparatively low computational budget. To the best of our knowledge, there is currently no methodology available that can identify regions in the design space that result in designs satisfying the local requirements set by the SSM due to the complexity and strong nonlinearity of crashworthiness simulations. The proposed coupling exploits the information of SSM and the capabilities of ALR to provide a fast mapping between the global requirements and the design parameters, which can, in turn, be made available to the designers to inexpensively evaluate the crashworthiness of new shapes and component features.

1 Introduction

Designing a new vehicle is a challenging process. It requires the expert knowledge of designers and engineers to find a balance between contrasting requirements, such as the need for lightweight vehicles and the safety of the passengers. To help the developers navigate these contrasts, a popular strategy is to use the tools developed in the field of systems engineering. These tools generally help to better formulate the requirements. They, however, do not help identify possible solutions, i.e., a physical design of the product, to fulfill all requirements. In this work, we consider how the challenge of identifying possible requirements-worthy designs can be solved when using the Solution Space Method (SSM) [1] as the support tool from the field of systems engineering.

To handle the overall complexity of vehicle design, SSM cascades the requirements from a global level to the local level of vehicle components. With requirement on a global level, or global requirement, we refer to a condition the whole vehicle must fulfill. Whereas, by a local requirement, we mean the requirement each single vehicle component must fulfill so that the final assembly meets the overall global requirement. For example, in the field of passive safety, the global requirements to mitigate the risks of injury of the passengers linked to a high-speed crash are stated in the protocols released by safety rating agencies, like the National Highway Traffic Safety Administration [2]. The local requirements for passive safety are, for example, how much energy each component must dissipate and how much each component is allowed to deform. If all local requirements are met by each component, then the global requirements are met, and the passengers will not suffer major injuries in a high-speed crash. In SSM, the requirements are cascaded down to a set of components de-emed relevant for the specific passive safety study. Therefore, SSM reformulates the risk mitigation strategies of the whole vehicle on a local level. Thanks to SSM, each component can be developed to fulfill the global requirements, thus being crashworthy, independently of the development of the other components. This is achieved by defining how much each component must deform, di in Fig. 1, and the force range each component must oppose during the impact, the white areas in Fig. 1. Therefore, the local requirements are presented in the form of force ranges over a defined deformation length, called corridors. An example of a typical set of corridors for a whole vehicle is later presented in Sec. 5.1.

Fig. 1
Example of corridors computed by the solution space method for crashworthiness. d1 and d2 are the expected deformation lengths for each component, while F1,2l and F1,2u are the lower and upper bounds of the computed force ranges, i.e., corridors. The corridors, meaning the crashworthy force ranges, are depicted by the white areas.
Fig. 1
Example of corridors computed by the solution space method for crashworthiness. d1 and d2 are the expected deformation lengths for each component, while F1,2l and F1,2u are the lower and upper bounds of the computed force ranges, i.e., corridors. The corridors, meaning the crashworthy force ranges, are depicted by the white areas.
Close modal
Fig. 2
Flowchart with the overview of the entire process for training the crashworthiness classifier
Fig. 2
Flowchart with the overview of the entire process for training the crashworthiness classifier
Close modal

By cascading global requirements, the SSM delivers to the designers and engineers a condition on the performance of the components under development [3,4]. However, it does not provide any information about the structure or geometry of the design of the components. Hence, the SSM is limited by the unknown and generally complex mapping between local requirements and actual designs. This gap, to our knowledge, is nowadays filled by the expertise of the designers themselves, but no research has proposed quantitative ways to estimate such a mapping. With the methodology we present in this paper, we fill this gap by introducing a quantitative method to identify the regions of the design space that map into the safety corridors defined by SSM. This is known in machine learning as the pre-image problem [5]. By identifying the pre-image of the corridors, we cascade the global requirements once more on the physical design of components instead of stopping on the performance level of the components. This step identifies specific structural properties of a component, hereinafter called design parameters, that render the performance of the component itself fulfill the corridors of SSM. By doing so, we provide a tool to the engineers and developers to help them explore the potential of their new concepts and designs.

We provide a classifier that can be directly used to identify which set of design parameters yields a solution that fulfills the local requirements of the corridors and which does not, following the approach first introduced by Abbiati et al. [6]. We refer to the first type of sets as feasible configuration or crashworthy and to the others as infeasible configuration. By identifying the feasible design, we help developers and engineers design crashworthy components. This information is useful to, for example, constrain an optimization problem for crashworthiness and better exploit the design parameters available to the developers. To identify the crashworthy designs efficiently, we adopt and adapt, for the first time for crashworthiness to our knowledge, some of the core concepts from the field of active learning reliability (ALR) [68]. In classical ALR, a surrogate-model-based classifier is adaptively constructed from an expensive computational model, to efficiently identify small areas of the parameter space that result in the failure of an engineering system. We use a similar strategy to identify regions of the parameter space that result in feasible configurations. We first re-formulate the local requirements defined by SSM as a limit-state function, and then use the ALR algorithm to learn and identify the feasible areas in the domain of the design parameters. Instead of calculating the probability of failure of the system, we rather use the ALR algorithm to efficiently train a classifier that can identify at no added computational cost the crashworthiness of an unseen design. This classifier can then be used to constrain an optimization problem to design crashworthy components or to help developers unlock the full potential of their conceptual designs in relation to crashworthiness. This approach is related to the state-of-the-art in surrogate-aided reliability-based design optimization (RBDO, [9]), with the main difference being that the safety constraints are provided by SSM. By doing so, SSM allows an increase in the overall design flexibility compared to solving a secondary nested reliability problem [3].

The main contributions in this work are:

  • Reformulating the corridors of SSM as an equivalent reliability problem;

  • Using state-of-the-art active learning methods to map corridor spaces back into the design space;

  • Provide a fast classifier trained on the underlying physics-based model that can be used during the design phase to quickly assess design compliance with the SSM corridors.

The paper is organized as follows: Sec. 2 provides an overview of the relevant literature on the SSM. Section 3 introduces the basic concepts of reliability and the active learning strategies used in the field. Section 4 presents the new method, and Sec. 5 showcases an application on a realistic case study related to the redesign of the frontal crash-box of the 2013 Honda Accord (HomeNHTSA) [2]. Lastly, in Sec. 6, we comment on the results and discuss the methodology.

2 The Solution Space Method

The SSM belongs to the family of systems engineering tools used to support the development process. The method cascades a set of global requirements to a new product on a subsystem or even a set of single components as a set of local requirements. The purpose of this cascade is not only to simplify the development of a new product but also to allow the development of each component or subsystem independently of the others. Although the method is now applied in many different fields, like robotics [10] or driving dynamics [11], we focus on the field of crashworthiness.

In the field of crashworthiness, the SSM was first introduced by Zimmermann et al. [3]. More precisely, it was introduced to help fulfill the crashworthiness requirements imposed by the passive safety protocols. From its introduction, two different approaches have then been adopted in the crashworthiness field: the direct [12,13] and the indirect one [14]. The first is completely based on an analytical approach to describe mathematically the product, its components and expected behavior, and to cascade the global requirements. The second, instead, is based on sampling a model of the product and cascading the global requirements, i.e., defining the local requirements for each component, by testing them on the samples of the said model. We focus on the direct approach for crashworthiness. We invite the reader to consider the work of Graff et al. [15,16] for a more detailed explanation of the indirect approach.

According to the definition given by Fender et al. [13], a solution space is the space defined as
(1)

where xil, and xiu belong to the n-dimensional vector x of performance parameters whose mapping to the expected behavior (xy) fulfills all global requirements. The vector x describes a set of properties of each component making up the final product.

This solution space is then optimized to find the biggest space in which all xi are orthogonal to each other [17]. In other words, the biggest possible hypercube is placed inside Ω to define a subset where the properties of different components are independent of each other. According to Daub et al. [17], we define a subspace of the solution space
(2)

where the Cartesian product is imposed on the ranges of each xi. The resulting ranges are called corridors.

In the direct method, the mapping of the performance parameters to the expected behavior is generally done by a simplified analytical model [18], as we will see later for the crashworthiness case study. Thanks to the simplified modeling and the definition of corridors, SSM has become an industry-standard tool to support development. On the one hand, the simplified modeling allows the computation of the corridors to be very efficient and computationally affordable. On the other hand, the definition of corridors allows for more flexibility during development [3]. Both the convenience and flexibility of the method are desirable characteristics that brought the industry to adopt the method [4]. We, therefore, choose to adopt this methodology so that we can evaluate the local crashworthiness requirements quickly and economically while allowing us to define a full range of possible crashworthy designs, i.e., areas of feasibility and infeasibility.

For crashworthiness, x is a vector of force levels [F1,,Fn] the components are expected to oppose during a crash. Therefore, the solution space Ω is defined in the space described by the force level ranges [Fil,Fiu]. Consequently, also the corridors are an expression of the ranges on these force levels: Ωc=[F1l,F1u]××[Fnl,Fnu]. Imposing the Cartesian product means that, as long as the forces opposed by the components are inside the range [Fil,Fiu], the crashworthiness of the vehicle is always guaranteed and each component can be designed independently.

3 Reliability Analysis and Active Learning

Reliability analysis is a field of uncertainty quantification devoted to assessing the safety and reliability of engineering systems. It provides a collection of advanced methods for the estimation of the probability of failure of a system, due to the inherent uncertainty in its manufacturing, operating or environmental conditions. At the core of reliability analysis lies the concept of limit state function, an abstract function implicitly defined through its sign: it takes positive values when the system is operating nominally, and negative otherwise.

More rigorously, consider an Mdimensional vector xM with joint probability distribution xfX, that represents the uncertainty of environmental and system parameters under consideration. Consider also a computational model y=M(x) that calculates numerically a response quantity of interest (QoI) of the system for the set of parameters x, e.g., a finite-element model (FEM) evaluating the maximum force or displacement in a component during a collision. A valid limit state function is any function g(x) that takes negative values when x results in a system operating outside its intended conditions. Arguably, the most used class of limit state functions is that related to the exceedance of critical material parameters:
(3)

where ρadm is a the maximum admissible value of the QoI Y before the system fails. A limit state function partitions the input domain ΩX into two classes: a safe domainDS, that includes all the subsets of ΩX such that g(x)>0,xDS, and a failure domainDF that satisfies instead g(x)0,xDF.

Within this framework, the probability of failure Pf of the system is simply defined as the probability that the limit state function takes negative values, given the joint distribution fX
(4)

The estimation of the integral in Eq. (4) is, in general, rather complex, as the failure domain DF is only known implicitly through the sign of the limit-state function, which in general requires costly evaluations of the computational model M. Several approaches are available to estimate it in the literature. Some of these are based on the approximation of the limit-state function with linear functions or with other semi-analytical methods [19,20]. The accuracy of these methods highly depends on the number of samples considered in the approximation. Therefore, applying these methods is usually computationally intensive because they generally require a high number of evaluations.

3.1 Active Learning Strategies for Efficient Sampling.

To overcome the generally high computational effort required by the classical methods for estimating DF, the last decade has seen the steady growth of a class of methods that capitalizes on recent advances in machine learning and surrogate modeling, namely, active-learning-based reliability analysis [7,8].

Active learning in reliability analysis refers to the process of evaluating the computationally intensive limit-state function on a relatively small set of points, determined iteratively, that maximize the estimation accuracy of Pf at each iteration [7,8].

The principle behind this class of methods, which belongs to the more general family of greedy algorithms, is to iteratively construct an inexpensive-to-evaluate approximation (a.k.a. a surrogate model) of the limit state function ĝ(x)g(x), based on a comparatively small number of full model evaluations, known as the experimental design. The choice of samples to add to the experimental design is based on maximizing a so-called learning functionL(x), which associates to each point in the input domain a score related to the expected improvement in the accuracy of the Pf estimator. A vast body of literature is dedicated to the specific choice of learning functions for reliability analysis, and the user is referred to both Teixeria et al. [7] and Moustapha et al. [8] for a more in-depth discussion. Because the failure probability Pf in Eq. (4) only depends on sign(g(x)), active-learning-based approximations tend to focus the expensive computational model evaluations only in the areas close to the safe-to-failure domain transition g(x)=0, commonly known as the limit state surface. In other words, central to all active learning methods is an accurate classifier of the safe and failure domains, trained at the lowest possible cost.

Despite the obvious differences between the plethora of methodologies available in the structural reliability literature, all active learning-based reliability methods share the same overall algorithmic structure [8]

  1. Train an initial surrogate model of the limit-state function ĝ(x) based on a small sample Xini={x(1),,x(Nini)} that follows the joint input distribution fX, with NiniO(101), known as the initial experimental design.

  2. At each iteration i, Estimate an approximate probability of failure Pf(i) based on the current surrogate, as well as its associated confidence bounds and accuracy measures, if available. This estimation is typically performed using simulation-based methods, due to the extremely low costs of evaluating the surrogate over a large set of input parameters.

  3. Minimize a suitable learning function (LF) over the input domain to identify the next point (or set of points) to be added to the current experimental design. A learning function is a generic mapping j:M that associates to each point in the input domain a value of information that is suitable for the learning goal at hand. Such value of information is typically related to the expected changes in misclassification probability of the surrogate limit state function ĝ(x), or to the reduction of the variance in the estimation of Pf(i+1).

  4. Add the chosen point x*=minxΩXLF(x) to the current experimental design, and train a new surrogate of the limit state function.

  5. Repeat steps 2-4 until some stopping criterion is met, i.e., convergence is achieved, or the available computational budget is exhausted.

Once the algorithm has completed, its final estimates of Pf and its confidence bounds are returned.

A large body of literature is available on the many different configurations of each of these steps, but an in-discussion on their performance is outside the scope of this paper and has been extensively covered by Moustapha et al. [8].

3.2 Active Learning Reliability for Training Classifiers.

While not extensively used in reliability analysis applications (if not for failure mode identification, see , e.g., the work of Sauder et al. [21]), a by-product of all ALR algorithms is the final trained surrogate model ĝ(x), which provides a powerful classifier for the identification of DF and DS, without the need to run additional expensive computational model evaluations. Outside the field of reliability analysis, the use of ALR algorithms as tools to build a standalone classifier has been recently introduced by Abbiati et al. [6], where the algorithm in Sec. 3 has been used to guide an experimental campaign to characterize the buckling behavior of steel plates.

A key difference between the use of ALR within reliability analysis versus pure classifier training lies in the joint distribution of the input parameters fX, which represents the actual parametric and operational uncertainty in the former, while it only defines the allowed parameter space in the latter. In particular, all the parameters of the classifier are considered independent and uniformly distributed between the minimum and maximum bounds defined by the application under investigation.

In the crashworthiness field, methods like SSM already provide a set of criteria on each component—local requirements—to understand whether or not a design fulfills the safety requirements on the whole vehicle—global requirements. However, the local requirements returned by the SSM are in the form of a set of ranges of force levels that a component is required to oppose during deformation. Consequently, to understand if the design of component k fulfills the ranges [Fi,kl,Fi,ku], it must be tested. Testing, generally, is rather expensive since it is performed with computationally intensive finite element simulations.

In contrast, building a standalone classifier using the ALR method is a cost-effective solution to finding designs that fulfill the corridors of the SSM. As shown by Abbiati et al. [6], a relatively small number of evaluations is required to identify the failure areas in a given domain. Therefore, we can train a similar classifier to identify which designs yield a set of force levels inside the given corridors [Fi,kl,Fi,ku] and which ones do not. Therefore, training such a classifier can significantly reduce the costs of developing new components for crashworthiness. In this paper, we propose, for the first time to our knowledge, a methodology to build this type of classifier that provides a tool to identify crashworthy designs of any given component. From a more practical point of view, we exploit the local requirements defined by the SSM to define the limit state function used by ALR to learn which combinations of design parameters are crashworthy and which are not.

4 Solution-Space-Based Crashworthiness Classifier

Our goal is to train a classifier capable of identifying crashworthy design inside the design domain using ALR and the SSM. We use SSM to define the local crashworthiness requirements of a component and then use ALR to train a classifier capable of distinguishing between designs that fulfill these local requirements and those that do not. The use of ALR for this application, though, requires some small changes. Normally, the algorithm is used to estimate the probability of failure of a given engineering system. Instead, we use the active learning capabilities of this algorithm to train a surrogate that accurately reproduces the sign of the limit state function, which directly translates to the two states of the classifier.

Firstly, we need to define a suitable function g that encodes the relation between the corridors and the force levels measured in a crash test of a component. Notice that, when formulating g(x), the vector x contains a set of design parameters of a component that are controlled during the test, such as the shell thickness and the impactor mass. These are not to be confused with the performance parameters of the solution space, i.e., the force levels F1,,Fn.

According to the definition of the corridors of the SSM, see Sec. 2, given a component k and set of force levels Fmsr=[F1,k,msr,,Fn,k,msr] measured during testing, a design is de-emed crashworthy when every measured force Fi,k,msr satisfies
(5)
We can split Eq. (5) into two separate equations. The first
(6)

Defines a condition in which the term Fi,k,msrFi,kl is negative when the corridor is violated—the measured force is lower than the allowed level—and, vice versa, it is positive when the corridor is fulfilled.

The second equation relates instead to the upper limit. In the equation
(7)
the term Fi,kuFi,k,msr is negative when the measured force is above the allowed level, i.e., violating the corridors of the SSM. Otherwise, Fi,kuFi,k,msr is positive. If the condition in Eq. (5) is satisfied, then, both Fi,k,msrFi,kl and Fi,kuFi,k,msr are positive. If instead one of the conditions in Eqs. (6) and (7), then Fi,k,msrFi,kl or Fi,kuFi,k,msr is negative. Therefore, to define a function g(x) according to the definition in Sec. 3, we consider the minimum value between the terms in Eqs. (6) and (7)
(8)

for each i-th measured force level of component k.

On top of the conditions listed so far, we must define an extra function hn+1,k(x) that relates to the expected deformation used in Eq. (10) and defined in the stepwise simplification introduced by Lange et al. [18]. According to them, a component cannot deform more than a predefined length. Therefore, the deformation length dmsr measured during the crash test, cannot exceed a predefined value dmax. Therefore, since dmsrdmax, we can define an extra condition, the i+1-th one, for defining the limit state function
(9)

Finally, to define a limit state function g(x) that accounts for all (n+1)-th conditions of component k, we consider the minimum among all hn+1(x). This way, the value of g(x) is negative if at least one of the i-th force ranges is violated or if dmsrdmax, corresponding to the classical definition of a series system (failure occurs if any of the constraints is violated). Instead, if all i-th force ranges are fulfilled and the deformation length is smaller than dmax, then g(x)0.

We feed the values of g(x) to the ALR algorithm to learn DS and DF in the domain of design parameters. In other words, the algorithm follows the steps described in Sec. 3.1 to learn an approximation ĝ(x) of the limit state function g(x). In the end, the learned function is used as our classifier. Given a set of design parameters x, if ĝ(x)0, the design fulfills all corridors, thus the crashworthiness requirements. Otherwise, if ĝ(x)0, at least one of the corridors is violated; thus, the crashworthiness requirements are not met. The overall process is visualized in the flowchart of Fig. 2.

Fig. 3
From the 2013 Honda Accord model [2] to the solution space corridors [23], via Deformation Space Model [18] of the car considering seven components. In the solution space corridors, the white area represents the feasible force ranges, while the gray area represents the infeasible force ranges.
Fig. 3
From the 2013 Honda Accord model [2] to the solution space corridors [23], via Deformation Space Model [18] of the car considering seven components. In the solution space corridors, the white area represents the feasible force ranges, while the gray area represents the infeasible force ranges.
Close modal

5 Application to a Realistic Design Test Case

To help showcase the potential of the methodology we are proposing, we present an application example in this section. To this purpose, we consider as a starting point the example presented by Daub [17] as a practical application of the SSM. The authors imagine redesigning the 2013 Honda Accord, available from the National Highway Traffic Safety Administration [22]. We, then, consider the frontal crashbox of the Honda Accord considered by Daub [17] and apply our methodology.

5.1 Application of the Solution Space Method to the 2013 Honda Accord.

The application of the computation of the corridors for the 2013 Honda Accord study presented by Daub [23] studies how the vehicle is expected to behave in a front impact with a rigid barrier and full overlap, according to the protocols of the National Highway Traffic Safety Administration [2].

We first need to identify the subsystem responsible for the crashworthiness of the vehicle during a frontal impact. In the Honda Accord, seven components are expected to dissipate most of the energy of the car during the impact. These components are divided into two load paths that deform at the same time. Then, to formulate the model itself, the properties of the components are considered for the stepwise simplifications necessary to represent the car and the crash performance [18]. These simplifications correlate the properties of the vehicle, like mass and velocity at the beginning of the impact, with the total deformation of each component. This correlation then defines the so-called deformation space model shown in the intermediate step of Fig. 3. In the deformation space model, the deformation length of each component is also divided into several sections. For example, with reference to Fig. 3, Component 1 is divided into nine sections, while Component 4 in only two. Each section is then associated with one of the force levels composing the vector of performance parameters F. The combination of force and deformation fully describes the performance of the vehicle during the frontal impact for our purpose.

To explicit the relation between F and y, we consider the protocol of the National Highway Traffic Safety Administration [2]. The global requirements we are interested in modeling are summarized in the following three conditions:

  1. The vehicle must be able to dissipate at least the kinetic energy of an impact at 56 km/h;

  2. The maximum deceleration during the impact cannot be higher than 300 m/s2;

  3. The components must deform in a pre-defined order.

These three statements provide the conditions imposed by Daub [23] on the vector of performance parameters F. The first one, also referred to as energy constraint, imposes that the sum of the energy dissipated in each section must be at least equal to the energy possessed by the vehicle. In other terms
(10)

where di is the deformation length of the section defined in the deformation space model, and Fi is the force level associated with the same section. Finally, K is the kinetic energy the Honda Accord possesses when driving at 56 km/h in the conditions defined in the protocol of the National Highway Traffic Safety Administration [2].

The second condition, referred to as impulse constraint, is related to the deceleration in each section
(11)

where mi is the active mass of the i-th section, as defined by Daub [23], and amax is the maximum allowed deceleration.

Lastly, the force level of the first section of a component must be greater than all force levels of the previous components, in the order in which they should deform. This condition is introduced for reparability. For example, with reference to Fig. 2, Component 2 deforms after Component 1. Consequently, if the maximum force level allowed in Component 1 is 50 kN, then the minimum force level allowed in the first section of Component 2 must be at least 50 kN. The relation Fy is, in the end, expressed by a set of equations coming from the conditions reviewed above.

In the last step of the methodology presented by Daub [23], the solution space Ωc is computed. In other words, a subspace of n is defined where all conditions on the vector F are satisfied and the Cartesian product [F1l,F1u]××[Fnl,Fnu] can be imposed. All ranges [Fil,Fiu] are represented in the panel to right of Fig. 2. In this application example, we consider only one component, namely, Component 4, a simple crash box.

5.2 Test Case: A Simple Crashbox.

As we just said, for the sake of simplicity, we focus only on Component 4, i.e., the crashbox shown in Fig. 4. The local requirements on this component are defined by a maximum deformation length and two corridors [17]. These quantities are shown in Fig. 5. More specifically:

Fig. 4
Setup of the droptower test of the studied crashbox
Fig. 4
Setup of the droptower test of the studied crashbox
Close modal
Fig. 5
Corridors of the crashbox [23]
Fig. 5
Corridors of the crashbox [23]
Close modal
  1. The component is allowed to deform of a maximum length dmax=54 mm;

  2. The component must absorb a force in between F1l=0 kN and F1u=65.93 kN while its deformation length ranges from 0 to 28 mm (first section);

  3. The component must absorb a force in between F2l=0 kN and F2u=66.02 kN from 28 to 54 mm of deformation (second section).

According to Sec. 4, we need to measure from a crash test the mean force over each section, Fi,k,msr, and the total deformation length dmsr. To do so, we simulate the crash test with a Finite Element model of a drop-tower test of the said component. For the purpose of the simulation, we use the commercial software LS-Dyna [24], and the open-lasso-dyna library [25], to interface the solver with the Python coding language. The simulation setup we use is shown in Fig. 4. The bottom side is clamped, meaning that all degrees-of-freedom of nodes on the bottom row are blocked. On the other end of the crashbox, the impactor is modeled as a rigid wall with initial velocity v0 and mass m. The component itself is then divided into two parts: Part 1 in blue, and Part 2 in green. Each part is linked to a different thickness value of the shell elements, respectively t1 and t2. The parameters m, t1, and t2 are the set of design parameters we consider as the design variables of our problem. For convenience, we measure the force opposed by the component and the deformation length at the rigid wall. The practice has shown us that, due to the heavy postprocessing we apply to the results, measuring the force in a different manner does not affect the end results. When measuring the total deformation length, we account for 1 mm of free fall of the rigid wall. This distance is set in the simulation to avoid any initial penetration, but also to be accounted for in the postprocessing of the results.

Always according to Sec. 4, we define in the simulation a set of design parameters that we can easily control. These are the two thickness values, t1 and t2, and the mass of the impactor m. In other words, x=[t1,t2,m]. We chose these three parameters to guarantee a visible effect when changing the design parameters across their domain.

Lastly, we postprocess the results coming from the finite element simulation. In the postprocessing, we compute the force levels Fi,k,msr, and the total deformation length dmsr. To do so, we consider the force-deformation curve measured at the rigid wall. Since for this component there are only two sections, thus two corridors, we compute only two force levels: F1,msr, and F2,msr. The first value is the average force opposed between 0 and 28 mm of deformation. The second, instead, is the average force opposed between 28 and 54 mm of deformation. F1,msr, F2,msr, and dmsr are then used to compute the limit state function g(x).

5.3 Definition of the Limit State Function.

As introduced in Sec. 4, the limit state function of the crashbox example is defined as the minimum of three subfunctions hi(x)
(12)
The first and second functions are related to the two corridors. Thus, they are defined according to Eq. (8)
(13)
(14)
The last function h3(x) expresses the condition on the maximum displacement. Therefore, it is formulated according to Eq. (9)
(15)

The limit state function we just defined is positive if 0F1,msr65.93 kN, 0F2,msr66.02 kN, and dmsr54 mm. If at least one of these conditions is violated, then g(x) is negative.

Having defined a limit state function, we can apply the ALR algorithm to learn an approximation ĝ(x) of g(x) that is accurate in sign. To do so, we use the implementation of the ALR algorithm available in the uqlab software [26,27]. The algorithm provides several options for the surrogate model, the enrichment strategy, and the stopping criteria. Following the recommendations of Moustapha et al. [8], we use polynomial-chaos-based Kriging as a surrogate model, and subset simulation as the reliability estimation method. We start with an initial experimental design of 20 samples. As a stopping criterion, we simply use a fixed budget of 250 additional finite element simulations, resulting in a total of 270 model runs. Because the ALR algorithm requires a probabilistic description of the input parameters, we provide the three design parameters t1, t2, and m as uniform random variables, following the recommendation in Abbiati et al. [6]. This choice avoids creating a priori preferential regions in the design space, allowing for an even exploration by ALR. While t1 and t2 range between 0.7 and 4.0 mm, the mass m ranges from 20 to 200 kg. These ranges are arbitrarily chosen, yet they lead to reasonable results for such a crashbox. For clarity, the variables and their properties are summarized in detail in Table 1, while the detailed settings used in the ALR algorithm are summarized in Table 2.

Table 1

Summary of the design variables of the crashbox

NameTypeRange
t1Uniform(0.7mm,4.0mm)
t2Uniform(0.7mm,4.0mm)
mUniform(20kg,200kg)
NameTypeRange
t1Uniform(0.7mm,4.0mm)
t2Uniform(0.7mm,4.0mm)
mUniform(20kg,200kg)
Table 2

Summary of the options used in the ALR algorithm

ALR settingOption
Surrogate model functionPolynomial-chaos-based kriging
Reliability estimatorSubset simulation
Stopping criteriaMaximum number of evaluations: 270
Size initial data-set20 samples
Number added samples250 samples
ALR settingOption
Surrogate model functionPolynomial-chaos-based kriging
Reliability estimatorSubset simulation
Stopping criteriaMaximum number of evaluations: 270
Size initial data-set20 samples
Number added samples250 samples

After completing the algorithm, ĝ(x) is trained on the 270 samples, of which 20 initial samples are sampled with a Latin Hypercube sampling strategy (LHS [28]), and 250 samples are actively placed by the ALR algorithm. We can now use ĝ(x) as a classifier to predict the crashworthiness of a design. According to the definition of g(x), a design is classified as crashworthy when ĝ(x)0 and it is unworthy when ĝ(x)0.

5.4 Results.

To assess the robustness of the method, we repeat the training NR=30 times, each time changing the initial random seed to capture its sensitivity to its initialization. For the sake of validation, we also generate a large out-of-sample validation set, consisting of NVal=10,000 full LS-Dyna simulations, postprocessed to evaluate the quantities F1,msr, F2,msr, and dmsr, thus g(x). This validation set is generated using LHS. Each of the NR replications is compared against this reference set to estimate meaningful accuracy metrics.

For each training run, we track three performance indicators: the percentage of misclassified samples, the percentage of samples classified as feasible that are misclassified—hereinafter referred to as feasible relative error —, and the percentage of samples classified as infeasible that are misclassified—hereinafter referred to as infeasible relative error. The evolution of the first index is shown in Fig. 6(a), in which the solid line marks the average percentage of samples misclassified—i.e., the median total error of the classifier—over the 30 runs. The total error is consistently decreasing during training and converges around 1.04%. The shaded area represents the empirical 10-90% confidence bounds on the total error, based on the available replications. The confidence interval settles around a value of 1.17%. In this application, we observe a maximum misclassification of 2.86%. The overall performance of the classifier for this application is also reported in the confusion matrix of Fig. 7. In this matrix, we report the absolute and relative mean and standard deviation of the number of misclassified samples. To compute the relative number, we consider the ratio between the prediction and the number of samples of the true class. The matrix confirms the good performance of the classifier, with the majority of the validation samples being correctly classified.

Fig. 6
Convergence of the percentage of misclassified samples: (a) the percentage of the 10,000 samples misclassified by the trained classifiers; (b) the percentage of the samples classified as feasible that have been misclassified in magenta, and the percentage of the samples classified as infeasible that have been misclassified in orange. The solid line shows the median value over the 30 repetitions, the shaded area shows the 10–90% confidence interval.
Fig. 6
Convergence of the percentage of misclassified samples: (a) the percentage of the 10,000 samples misclassified by the trained classifiers; (b) the percentage of the samples classified as feasible that have been misclassified in magenta, and the percentage of the samples classified as infeasible that have been misclassified in orange. The solid line shows the median value over the 30 repetitions, the shaded area shows the 10–90% confidence interval.
Close modal
Fig. 7
Confusion matrix of the trained classifier with the median performance
Fig. 7
Confusion matrix of the trained classifier with the median performance
Close modal

In Fig. 6(b), the purple curve and shaded area represent the median feasible relative error and its empirical 10-90% confidence interval over the 30 runs. On average, this relative error settles at 6.39%, while its confidence interval at 3.45%. The orange curve and shaded area in the figure, instead, represent the infeasible relative error (respectively median and 10–90% confidence interval). The median error converges to 0.87%, with a standard deviation of 1.25%.

Of the 30 runs, we show more in detail the one with a total error of 1.02% — , i.e., it misclassifies a total of 102 samples. Of these 102 samples, 48 are samples wrongly classified as feasible, and 54 are wrongly classified as infeasible. Therefore, the relative feasible error of this run is 6.93%, and the relative infeasible error is 0.58%. Since the domain of the design parameters is three-dimensional, we can visualize DF and DS, i.e., the crashworthy domain and the unworthy one. To do so, we slice the domain by fixing each design parameter at a time and plotting a slice at the fixed value. Figure 8 shows the comparison between the estimated feasible areas (in magenta) and the actual feasible areas (in gray) obtained from the validation set. To obtain the reference shaded areas in gray we linearly interpolate between the values of g(x) of the 10,000 validation samples evaluated with LS-Dyna. Similarly, to obtain the estimated feasible areas on the given slice, we interpolate between the 10,000 validation samples evaluated on the approximation ĝ(x) returned by the ALR algorithm. This figure makes use of the converged classifier and allows us to understand how well the trained classifier is approximating the feasible areas. The slices are placed in areas of interest. For t1 and t2, two slices are placed close to the borders of the domain and two are placed in the mid-dle. For m, the four slices are placed in the lower part of the domain (lower than 50 kg). The rest of the domain is mainly empty, hence, not of interest. This figure allows us to assess how the classifier estimates the feasible areas in the design domain after a total training cost of N=270 samples. By interpolating between the 10,000 samples of the validation set, we can visualize the complicated topology of the feasible area, its small volume (approximately 7% of the design space), and the areas where the classifier accuracy is reduced. The real and estimated feasible areas are mostly overlapping. However, the classifier starts to show inaccuracies where the true feasible area has many small isolated peaks, around m=40 kg and m=50 kg. Please note that a quantitative interpretation is difficult because of the limited data available for interpolation. As shown in Fig. 6, the overall accuracy of the classifier increases with the available computational budget, and we, therefore, expect that even these areas would be better reconstructed with further iterations of the algorithm.

Fig. 8
Comparison between the feasible areas estimated by the trained classifier and defined by the validation set of 10,000 simulations. The gray area is the feasible area according to the validation set, the magenta area is the estimated feasible area. The 12 slices are taken for the following values: t1=0.75,2.0,3.0,3.95 mm, t2=0.75,2.0,3.0,3.95 mm, and m = 25, 30, 40, 50 kg.
Fig. 8
Comparison between the feasible areas estimated by the trained classifier and defined by the validation set of 10,000 simulations. The gray area is the feasible area according to the validation set, the magenta area is the estimated feasible area. The 12 slices are taken for the following values: t1=0.75,2.0,3.0,3.95 mm, t2=0.75,2.0,3.0,3.95 mm, and m = 25, 30, 40, 50 kg.
Close modal

Finally, Fig. 9 provides a comparison between the feasible area estimated by the ALR algorithm and the feasible area defined by the validation set of 10,000 simulations throughout the training of the classifier. In this figure, we show one slice per dimension per training snapshot. Therefore, the slices are placed at t1=1.0 mm, at t2=1.0 mm, and the last at m=30 kg. The snapshots of the training are taken with 50, 100, 200, and 270 samples: in other words, toward the beginning of the training, in the mid-dle of the training, and at convergence. The areas marked in gray are the feasible areas according to the validation set. The areas in magenta are the feasible areas according to the trained classifier. This figure allows us to compare the validation set with the trained classifier at different stages of training to understand how the algorithm behaves. For more detailed plots, the reader is referred to the Appendix.

Fig. 9
Evolution of the estimated feasible area during training. Each row shows three slices placed at t1=1.0 mm, t2=1.0mm, and m = 30 kg. The first row shows the estimated feasible area after the evaluation of 50 samples (20 points of initial DoE and 30 iterations). The second row shows the said area after 100 samples (20 points of initial DoE and 80 iterations). The third row shows the area estimated with 200 samples (20 points of initial DoE and 180 iterations). The last row shows the feasible area at convergence, i.e., after having evaluated 270 samples. The gray area shows the feasible areas according to the validation set. The magenta areas, instead, show the feasible areas estimated by the trained classifier.
Fig. 9
Evolution of the estimated feasible area during training. Each row shows three slices placed at t1=1.0 mm, t2=1.0mm, and m = 30 kg. The first row shows the estimated feasible area after the evaluation of 50 samples (20 points of initial DoE and 30 iterations). The second row shows the said area after 100 samples (20 points of initial DoE and 80 iterations). The third row shows the area estimated with 200 samples (20 points of initial DoE and 180 iterations). The last row shows the feasible area at convergence, i.e., after having evaluated 270 samples. The gray area shows the feasible areas according to the validation set. The magenta areas, instead, show the feasible areas estimated by the trained classifier.
Close modal

6 Discussion

The results from the practical application presented in Sec. 5.4 indicate that the methodology we are proposing efficiently and effectively trains a classifier capable of distinguishing crashworthy designs from noncrashworthy ones. With just 270 samples, we are capable of training a classifier with a median total error of 1.04%.

The fact of having a median total error of 1.02%, despite the small volume of the feasible domain, is possible due to the active learning strategy. This type of learning places most samples close to areas generally treated as of high interest, according to the learning functions defined in Sec. 3. Figure 6 shows that the chosen learning strategy is very effective: the algorithm quickly identifies the feasible area and the estimation error quickly drops to a small value. The ability to locate samples “smartly” increases the accuracy of the classifier while keeping low the training effort. In other words, we spend computational power only where needed, namely, at the boundaries of the crashworthy areas. This contrasts with the more common technique of building a general surrogate of the whole finite element simulation and using its output to test the feasibility against a set of local requirements [29].

The effectiveness of the ALR tools is also evident in Fig. 9. The plots in the first row show that 50 samples are not enough to properly approximate the feasible areas. However, as the second row indicates, 100 samples already yield a good approximation of these areas. At this stage, the total error is already well below 5%. The majority of this error is attributed to the fact that there are feasible areas with complicated topology. For example, an area that requires more attention is around the point with t1=1.0 mm, t2=0.8 mm, and m=0.03 ton, on the left bottom corner of the third plot on the second row of Fig. 8. This fact indicates that the algorithm tends to behave conservatively, by classifying crashworthy samples as not-crashworthy, rather than vice versa. From a practical point of view, this is in favor of a more robust development: the algorithm first identifies big areas of success, and then slowly expands them to refine the approximation.

More evidence of the conservativeness of the algorithm is found in Fig. 6. While Figure 6(a) indicates that the classifier becomes more and more precise with each iteration, the plot in Fig. 6(b) indicates that most of the improvements are made on reducing the number of crashworthy samples misclassified, and thus the feasible relative error. The fact that the feasible relative error is always bigger than the infeasible relative error supports the conservativeness of the algorithm. On top of this, both relative errors remain relatively stable after the 200th evaluation. At this stage, the total error is still slightly decreasing. Therefore, we can infer that in this application, on average, by iteration 200 the algorithm has identified all feasible areas.

In this application, the algorithm starts refining the classifier after the 200th iteration. It does so by identifying small feasible areas encapsulated in infeasible zones, and vice-versa. The result of this refinement can be seen in the fully converged plots of Fig. 8 for m=25 kg. In this plot, the algorithm was capable of identifying some of the small infeasible areas that are completely surrounded by feasible zones. However, notice that letting the algorithm fully refine these areas provides only a limited benefit compared to the computational effort required. These areas are small enough to not de-eply affect the total error.

The relatively simple system selected to apply the proposed methodology, namely, a crashbox where we vary impactor mass and the side wall thicknesses, is done on purpose. By choosing such a well-known case study, we could understand better the very mechanisms of active learning in this new context. More challenging industrial case studies should be tackled in the near future.

In conclusion, our proposed method for training a crashworthiness classifier is efficient, accurate, and appears conservative in the selected case study. It is efficient because it uses a limited number of evaluations to identify the crashworthiness domain—with 200 samples, the classifier prediction already has an error lower than 5% according to Fig. 6(a). It is accurate because it converges with only 270 evaluations around a total error of only 1.04%. Finally, it is conservative because it favors misclassifying crashworthy samples, rather than misclassifying failing samples.

7 Conclusion

The methodology we present in this paper merges the SSM with ALR. This coupling provides an efficient and effective approach for addressing some of the challenges in finding crashworthy designs of components for new vehicles. By cascading global requirements via the SSM on a local level and utilizing ALR to propagate the cascaded local requirements on parametrized components, our approach provides a classifier capable of identifying possible crashworthy designs of the given component. The presented simple application—a crashbox with three design parameters—demonstrates the efficiency, accuracy, and conservativeness of the methodology. With a rate of only 2.5% of misclassification, we successfully train a crashworthiness classifier evaluating a total of 270 samples.

Our methodology should serve as a valuable new tool for designers and engineers. It offers an effective method to identify potential feasible designs at a low budget, thus unlocking the full potential of any given design. The positive outcomes of this study allow us to underline the importance of coupling systems engineering methods with machine learning to better exploit the information they provide and, thus, better support the development of new products.

Acknowledgment

The authors would like to thank Adéla Hlobilová for her invaluable support in the use of the uq[py]lab software.

Funding Data

  • European Union's Horizon 2020 research and innovation program under the Marie Skłodowska-Curie (Grant Agreement No 955393).

Data Availability Statement

The data and information that support the findings of this article are freely available at Footnote.1

Footnotes

References

1.
Zimmermann
,
M.
, and
DeWeck
,
O.
,
2021
, “
Formulating Engineering Systems Requirements
,”
Handbook of Engineering Systems Design
,
Springer
,
Cham, Switzerland
, pp.
1
49
.
2.
NHTSA
,
2024
, “
National Highway Traffic Safety Administration Laws and Regulation
,” accessed June 25, 2024, https://www.nhtsa.gov/laws-regulations
3.
Zimmermann
,
M.
, and
Von Hoessle
,
J. E.
,
2013
, “
Computing Solution Spaces for Robust Design
,”
Int. J. Numer. Methods Eng.
,
94
(
3
), pp.
290
307
.10.1002/nme.4450
4.
Zimmermann
,
M.
,
Königs
,
S.
,
Niemeyer
,
C.
,
Fender
,
J.
,
Zeherbauer
,
C.
,
Vitale
,
R.
, and
Wahle
,
M.
,
2017
, “
On the Design of Large Systems Subject to Uncertainty
,”
J. Eng. Des.
, 28(4), pp.
233
254
.10.1080/09544828.2017.1303664
5.
Kwok
,
J.-Y.
, and
Tsang
,
I.-H.
,
2004
, “
The Preimage Problem in Kernel Methods
,”
IEEE Trans. Neural Networks
,
15
(
6
), pp.
1517
1525
.10.1109/TNN.2004.837781
6.
Abbiati
,
G.
,
Marelli
,
S.
,
Ligeikis
,
C.
,
Christenson
,
R.
, and
Stojadinović
,
B.
,
2022
, “
Training of a Classifier for Structural Component Failure Based on Hybrid Simulation and Kriging
,”
J. Eng. Mech.
,
148
(
1
), p.
04021137
.10.1061/(ASCE)EM.1943-7889.0002048
7.
Teixeira
,
R.
,
Nogal
,
M.
, and
O'Connor
,
A.
,
2021
, “
Adaptive Approaches in Metamodel-Based Reliability Analysis: A Review
,”
Struct. Saf.
,
89
, p.
102019
.10.1016/j.strusafe.2020.102019
8.
Moustapha
,
M.
,
Marelli
,
S.
, and
Sudret
,
B.
,
2022
, “
Active Learning for Structural Reliability: Survey, General Framework and Benchmark
,”
Struct. Saf.
,
96
, p.
102174
.10.1016/j.strusafe.2021.102174
9.
Moustapha
,
M.
, and
Sudret
,
B.
,
2019
, “
Surrogateassisted Reliability-Based Design Optimization: A Survey and a Unified Modular Framework
,”
Struct. Multidiscip. Optim.
,
60
(
5
), pp.
2157
2176
.10.1007/s00158-019-02290-y
10.
Krischer
,
L.
, and
Zimmermann
,
M.
,
2021
, “
Decomposition and Optimization of Linear Structures Using Meta Models
,”
Struct. Multidiscip. Optim.
,
64
(
4
), pp.
2393
2407
.10.1007/s00158-021-02993-1
11.
Vogt
,
M. E.
,
Duddeck
,
F.
,
Wahle
,
M.
, and
Zimmermann
,
M.
,
2019
, “
Optimizing Tolerance to Uncertainty in Systems Design With Early-and Late-Decision Variables
,”
IMA J. Manage. Math.
,
30
(
3
), pp.
269
280
.10.1093/imaman/dpy003
12.
Fender
,
J.
,
2014
, “
Solution Spaces for Vehicle Crash Design
,” Ph.D. thesis,
Technical University of Munich
,
Munich, Germany
.
13.
Fender
,
J.
,
Duddeck
,
F.
, and
Zimmermann
,
M.
,
2017
, “
Direct Computation of Solution Spaces
,”
Struct. Multidiscip. Optim.
,
55
(
5
), pp.
1787
1796
.10.1007/s00158-016-1615-y
14.
Graff
,
L.
,
2013
, “
A Stochastic Algorithm for the Identification of Solution Spaces in High-Dimensional Design Spaces
,” Ph.D. thesis,
University of Basel
,
Basel, Switzerland
.
15.
Graff
,
L.
,
Harbrecht
,
H.
, and
Zimmermann
,
M.
,
2016
, “
On the Computation of Solution Spaces in High Dimensions
,”
Struct. Multidiscip. Optim.
,
54
(
4
), pp.
811
829
.10.1007/s00158-016-1454-x
16.
Graf
,
W.
,
Götz
,
M.
, and
Kaliske
,
M.
,
2018
, “
Computing Permissible Design Spaces Under Consideration of Functional Responses
,”
Adv. Eng. Software
,
117
, pp.
95
106
.10.1016/j.advengsoft.2017.05.015
17.
Daub
,
M.
,
Duddeck
,
F.
, and
Zimmermann
,
M.
,
2020
, “
Optimizing Component Solution Spaces for Systems Design
,”
Struct. Multidiscip. Optim.
,
61
(
5
), pp.
2097
2109
.10.1007/s00158-019-02456-8
18.
Lange
,
V. A.
,
Fender
,
J.
,
Song
,
L.
, and
Duddeck
,
F.
,
2019
, “
Early Phase Modeling of Frontal Impacts for Crashworthiness: From Lumped Mass-Spring Models to Deformation Space Models
,”
Proc. Inst. Mech. Eng., Part D: J. Automob. Eng.
,
233
(
12
), pp.
3000
3015
.10.1177/0954407018814034
19.
Ditlevsen
,
O.
, and
Madsen
,
H. O.
,
1996
,
Structural Reliability Methods
,
178
,
Wiley Ltd
.,
New York
.
20.
Lemaire
,
M.
,
Chateauneuf
,
A.
, and
Mitteau
,
J.-C.
,
2009
, “
Structural Reliability,” Wiley Ltd
.,
Hoboken, NJ
.
21.
Sauder
,
T.
,
Marelli
,
S.
, and
Sorensen
,
A. J.
,
2019
, “
Probabilistic Robust Design of Control Systems for High-Fidelity Cyber–Physical Testing
,”
Automatica
,
101
, pp.
111
119
.
22.
NHTSA
,
2024
National Highway Traffic Safety Administration Crash Simulation Vehicle Models
,” accessed June 25, 2024, https://www.nhtsa.gov/crash-simulation-vehicle-models.
23.
Daub
,
M.
,
2020
, “
Optimizing Flexibility for Component Design in Systems Engineering Under Epistemic Uncertainty
,” Ph.D. thesis,
Technical University of Munich
,
Munich, Germany
.
24.
Ansys
,
I.
,
2024
, “
LS-DYNA: Crash Simulation Software
,” accessed June 25, 2024, https://www.ansys.com/products/structures/ansys-ls-dyna
25.
Open-lasso-python
,
2024
, “
open-lasso-dyna lasso-python
,” accessed June 25, 2024, https://github.com/open-lasso-python/lasso-python
26.
Marelli
,
S.
, and
Sudret
,
B.
,
2014
, “
UQLab: A Framework for Uncertainty Quantification in Matlab
,”
Proceeding of 2nd International Conference on Vulnerability, Risk Analysis and Management (ICVRAM2014)
,
American Society of Civil Engineers
,
Liverpool, UK
, July 13–16, pp.
2554
2563
.
27.
Moustapha
,
M.
,
Marelli
,
S.
, and
Sudret
,
B.
,
2022
, “
UQLab User Manual – Active Learning Reliability
,”
Report UQLab-V2, in Chair of Risk, Safety and Uncertainty Quantification
,
ETH Zurich
,
Zurich, Switzerland
, Report No. UQLab-V0.9-102.
28.
McKay
,
M. D.
,
Beckman
,
R. J.
, and
Conover
,
W. J.
,
1979
, “
A Comparison of Three Methods for Selecting Values of Input Variables in the Analysis of Output From a Computer Code
,”
Technometrics
,
21
(
2
), pp.
239
245
.10.2307/1268522
29.
Amsallem
,
D.
,
Zahr
,
M. J.
, and
Farhat
,
C.
,
2012
, “
Nonlinear Model Order Reduction Based on Local Reduced-Order Bases
,”
Int. J. Numer. Methods Eng.
,
92
(
10
), pp.
891
916
.10.1002/nme.4371