# Boundary modeling in model-based calibration for automotive engines via the vertex representation of the convex hulls

- Hayato Waki
^{1}Email author and - Florin Nae
^{2}

**9**:1

https://doi.org/10.1186/s40736-016-0027-7

© The Author(s) 2017

**Received: **5 July 2016

**Accepted: **14 December 2016

**Published: **5 January 2017

## Abstract

When using the convex hull approach in the boundary modeling process, Model-Based Calibration (MBC) software suites – such as Model-Based Calibration Toolbox from MathWorks – can be computationally intensive depending on the amount of data modeled. The reason for this is that the half-space representation of the convex hull is used. We discuss here another representation of the convex hull, the vertex representation, which proves capable to reduce the computational cost. Numerical comparisons in this article are executed in MATLAB by using MBC Toolbox commands, and show that for certain conditions, the vertex representation outperforms the half-space representation.

### Keywords

Convex hull Boundary modeling Optimization Model-based calibration Automotive engine MBC toolbox## Introduction

Model-Based Calibration (*abbr.* MBC) is a systematic approach for more cost-effective and short-term development of automotive engines, that enables engineers to design more efficient automotive engines, e.g., more fuel-efficient and/or eco-friendly engines. For efficient design of automotive engines, mathematical models for automotive engines are created in MBC, and statistics and optimization are applied to the model by using MBC software, such as [10].

Boundary modeling is one of the processes in MBC used to represent/approximate a region where the automotive engine works normally, e.g., without misfire and knock of the engine. We call the region *the admissible operation domain* (*abbr.* AOD). In general, as it is assumed that internal-combustion engines are highly nonlinear systems, it is impossible to exactly represent the AOD of the automotive engine from a finite number of acquired data. Thus one approximates the AOD instead of representing it exactly. One of the approximations of AOD is to use the convex hull of a set of data. This is a simple way to approximate AOD from data and is implemented in MBC software, such as [10]. In addition to the convex hull, the use of support vector machine for the approximation of AOD is also proposed in [7].

An AOD is used as a constraint in constrained optimization problems. One can assume that some of optimal solutions will lie on the boundary of the feasible region, otherwise the constraints would be irrelevant. That is why a proper handling of AODs is important in engine optimization problems.

The motivation of this article comes from the comment in [5] that some of the MBC software suites spend much computational time constructing a convex hull boundary model. In general, two representations for the convex hull of a set of points are possible, *the half-space representation* and *the vertex representation*. The reason for the comment was that the half-space representation for the convex hull of a set of points is typically used by software like MBC Toolbox, instead of the vertex representation.

The contribution of this article is to propose the use of the convex hull in the vertex representation instead of the half-space representation. In practice, the former representation seems to perform better than the latter. In fact, the numerical comparison in this article shows that the vertex representation is less computationally intensive than the hyperplane representation in the case when the dimension of inputs for engine models is more than five.

The organization of this article is as follows: convex hull modeling theory is discussed in Section 2. Section 3 provides an application of the vertex representation of the convex hull and numerical experiments. Conclusion is given in Section 4. Throughout this article, we assume that the measured engine data was acquired by keeping the engine under test at steady condition by controlling its inputs.

## Preliminaries

We give a brief introduction on boundary modeling via the convex hull in Section 2.1, and some definitions and facts on the convex hull for a set of points in Section 2.2. Refer to [2, 4] for more details regarding the convex hull mathematical representation.

### 2.1 Boundary modeling in model-based calibration

*t*is time,

**x**,

**u**and

**y**are vectors which represent the state of the automotive engine, the input signals into the engine and the output signals from the engine, respectively.

Control theory, statistics and optimization are applied to such mathematical models of automotive engines to design more fuel-efficient and/or eco-friendly engines. MBC is a systematic approach for aiding such an efficient design of automotive engines and consists of some processes, such as the design of experiments and the response surface methodology.

Boundary modeling is a functionality used in MBC, and is applied to define an AOD for a mathematical engine model. Input signals for automotive engines under development have specific operating ranges and dynamics. In addition, automotive engines may not behave normally when some specific input signals are used, leading to undesirable events such as misfire and knock of the engine. In boundary modeling, one approximates/represents a region of input signals where automotive engines behave normally, e.g., without misfire and knock of the engine.

Note that as we mentioned, the approximation of the AOD by the convex hull may be rough. In fact, it does not always represent the region where the automotive engine behave normally. For instance, the approximation at the right of Fig. 1 contains red circles, which means that the automotive engine does not behave normally around the circle.

- (P1)Problem of determining whether a new point is in the approximated AOD or not. This is mainly used in design of experiment of MBC and mathematically formulated as the problem of determiningwhere \(\hat {\mathbf {v}}\) is a new point and$$\hat{\mathbf{v}} \in P \, \text{or}\, \hat{\mathbf{v}} \not\in P, $$
*P*is an approximation of the AOD. - (P2)Optimization of some objective functions over the approximated AOD or a subset of the AOD for more realistic situation in response surface methodology. This is mathematically formulated aswhere$$\min_{\mathbf{v}\in\mathbb{R}^{n}}\left\{f(\mathbf{v}) : g_{j}(\mathbf{v}) \ge 0 \ (j=1, \ldots, k), \mathbf{v}\in P\right\}, $$
*f*(**v**) is the objective function and*g*_{ j }(**v**)≥0 is an engine operating constraint.

### 2.2 Convex hull for a set of points in \(\mathbb {R}^{n}\)

*V*={

**v**

_{1},…,

**v**

_{ m }} be a finite set of distinct points in \(\mathbb {R}^{n}\). A point

*convex combination*of

**v**

_{1},…,

**v**

_{ m }. In particular, the set {

*α*

**a**+(1−

*α*)

**b**:0≤

*α*≤1} is called the

*line segment with the endpoints*a

*and*b and denoted by [

**a**,

**b**].

*convex*if for every

**a**,

**b**∈

*K*, the line segment [

**a**,

**b**] is contained in

*K*. We define the empty set

*∅*as a convex set. Figure 2 displays an example of convex and nonconvex sets. In fact, for the set at the left of Fig. 2, we see that for every

**a**,

**b**in the set, the line segment [

**a**,

**b**] is contained in the set, which implies that the set is convex. In contrast, the line segment [

**a**,

**b**] is not contained in the set at the right of Fig. 2.

Let \(K\subseteq \mathbb {R}^{n}\) be a convex set. A point **x**∈*K* is an *extreme point* or *vertex* of *K* if **y**,**z**∈*K*,0<*α*<1 and **x**=*α*
**y**+(1−*α*)**z** imply **x**=**y**=**z**. In other words, an extreme point of *K* is not a convex combination of other points in *K*. For instance, at the set of the left in Fig. 2, the black circles at the corners indicate an extreme point of the convex set. We denote the set of extreme points in *K* by ext(*K*).

The convex hull conv(*A*) of a subset \(A\subseteq \mathbb {R}^{n}\) is the set of all convex combination of points from *A*.

*V*={

**v**

_{1},…,

**v**

_{ m }} of distinct points in \(\mathbb {R}^{n}, \text {conv}(V)\) is formulated mathematically as

*V*are extreme points of the convex hull, this representation of conv(

*V*) is called the

*vertex representation*(

*abbr.*V-representation). Figure 3 displays an example of the convex hull of

*V*={(0,0),(2,0),(3,2),(1,1),(0,1)}. Since all points except for (1,1) are extreme points, ext(conv(

*V*))={(0,0),(2,0),(3,2),(0,1)}. In fact, (1,1) is not the extreme point of the convex hull because (1,1) can be represented by a convex combination with (2,0),(3,2) and (0,1). In addition, we see conv(

*V*)=conv(ext(

*V*)) in Fig. 3.

A bounded convex set \(K\subseteq \mathbb {R}^{n}\) is a *polytope* if ext(*K*) is a finite set. Clearly the convex hull of a set of a finite numbers of points in \(\mathbb {R}^{n}\) is a polytope. A half-space is a set which is defined as \(\{x\in \mathbb {R}^{n} : \mathbf {a}^{T}\mathbf {x} \le b\}\), with suitable \(\mathbf {a}\in \mathbb {R}^{n}\) and \(b\in \mathbb {R}\). A set *P* is called *polyhedron* if *P* is formed as the intersection of finitely many half-spaces, i.e., there exist \(\mathbf {a}_{1}, \ldots, \mathbf {a}_{k}\in \mathbb {R}^{n}\) and \(b_{1}, \ldots, b_{k}\in \mathbb {R}\) such that \(P =\left \{ \mathbf {x} \in \mathbb {R}^{n} : \mathbf {a}_{i}^{T}\mathbf {x} \le b_{i} \ (i=1, \ldots, k) \right \}\).

Minkowski-Weyl’s theorem ensures that every polytope can be reformulated as a polyhedron. This implies that one can describe the convex hull of a set of points by some half-spaces in addition to the V-representation, which is called the *half-space representation* (*abbr.* H-representation).

###
**Theorem 2.1**

(Minkowski-Weyl) Every polytope is polyhedron, i.e., for a given polytope *P*, there exist \(\mathbf {a}_{1}, \ldots, \mathbf {a}_{k}\in \mathbb {R}^{n}\) and \(b_{1}, \ldots, b_{k}\in \mathbb {R}\) such that \(P=\{x\in \mathbb {R}^{n} : \mathbf {a}_{i}^{T}\mathbf {x}\le b_{i} \ (i=1, \ldots, k)\}\). Moreover, every bounded polyhedron is also polytope, i.e., for a given polyhedron *P*, there exist **v**
_{1},…,**v**
_{
m
}∈*P* such that *P*=conv(*V*), where *V*={**v**
_{1},…,**v**
_{
m
}}.

We give two examples of the V- and H-representations. We see from these examples that one needs to choose a suitable representation of the convex hull from the viewpoint of computation.

###
**Example 2.2**

*n*-dimensional unit cube) Let \(P = \{\mathbf {x}\in \mathbb {R}^{n} : 0\le x_{i}\le 1 \ (i=1, \ldots, n)\}\).

*P*is called the

*n*-

*dimensional unit cube*. Figure 4 displays an example of 3-dimensional unit cube. This is already the H-representation. In fact, we define \(\mathbf {a}_{i}\in \mathbb {R}^{n}, b_{i}\in \mathbb {R}\) (

*i*=1,…,2

*n*) as follows:

**e**

_{ i }is the

*i*th

*n*-dimensional standard unit vector. Then

*P*can be reformulated by \(\{\mathbf {x} \in \mathbb {R}^{n} : \mathbf {a}_{i}^{T}\mathbf {x}\le b_{i} \ (i=1, \ldots, 2n)\}\). On the other hand, for \(\text {ext}(P) = \{\mathbf {x}\in \mathbb {R}^{n} : x_{i} = 0 \text {or} 1\}\), the V-representation of

*P*is

We remark that the V-representation of *P* needs 2^{
n
} extreme points in ext(*P*), whereas the H-representation needs only 2*n* half-spaces.

###
**Example 2.3**

*P*is called the

*n*-

*dimensional cross-polytope*. Figure 4 displays an example of the 3-dimensional cross-polytope. The H-representation of

*P*is

Here the H-representation is the intersection of 2^{
n
} half-spaces. In contrast, the V-representation of *P* can be formulated by 2*n* points in \(\mathbb {R}^{n}\). In fact, since both **e**
_{
i
} and −**e**
_{
i
} are extreme points in *P*, the V-representation of *P* is *P*=conv({±**e**
_{1},…,±**e**
_{
n
}}).

A more compact representation of the convex hull is often useful from the viewpoint of computation. For instance, the V-representation in Example 2.2 and the H-representation in Example 2.3 require more computer memory even for small *n*, whereas the H-representation in Example 2.2 and the V-representation in Example 2.3 need less memory even for large *n*. Hence the H-representation in Example 2.2 and the V-representation in Example 2.3 are more suitable to deal with in actual computers when the dimension *n* is large.

## Application of the V-representation to model based calibration for automotive engines

We propose a way to handle the V-representation of the convex hull of a set of points without conversion into the H-representation in Sections 3.2 and 3.3. This way uses the results in [11]. Before mentioning them, we discuss the computational difficulty in using some MBC software in Section 3.1.

### 3.1 Computational difficulty due to the H-representation

*V*={

**v**

_{1},…,

**v**

_{ m }} be a set of input signals \(\mathbf {v}_{1}, \ldots, \mathbf {v}_{m}\in \mathbb {R}^{n}\). Then the approximation via the convex hull is formulated as conv(

*V*) and is the V-representation. On the other hand, for both (P1) and (P2) in Section 2.1, it is converted into \(P = \{\mathbf {v}\in \mathbb {R}^{n} : \mathbf {A}\mathbf {v} \le \mathbf {b}\}\) for some \(\mathbf {A}\in \mathbb {R}^{k\times n}\) and \(\mathbf {b}\in \mathbb {R}^{k}\) in some MBC software, such as [10]. This corresponds to the conversion of the V-representation of the convex hull conv(

*V*) into the H-representation, and after this conversion, (P1) and (P2) are respectively equivalent to

- (P1)’
Problem of determining whether \(\mathbf {A}\hat {\mathbf {v}}\le \mathbf {b}\) or \(\mathbf {A}\hat {\mathbf {v}}\not \le \mathbf {b}\), and

- (P2)’
Solution of \(\min _{\mathbf {v}\in \mathbb {R}^{n}}\left \{f(\mathbf {v}) : g_{j}(\mathbf {v}) \ge 0 \ (j=1, \ldots, k), \mathbf {A}\mathbf {v}\le \mathbf {b}\right \}\).

^{1}, we generated a set

*V*of

*m*points in [ −1,1]

^{ n }randomly and used vert2lcon.m in [9], which calls the built-in function convexhulln in MATLAB based on Qhull [12]. “–” in Table 1 indicates that we do not compute the conversion because it spends more than 1000 sec. We observe from Table 1 that when

*n*is not so large, the conversion is not so computationally intensive and is rather fast. However, when

*n*is larger (typically more than 10), generating the convex hull in the H-representation becomes computationally intensive. Moreover, since it generates many half-spaces, we can expect that the optimization in (P2)’ will also be computationally intensive.

Numerical results on the conversion of the V-representation into the H-representation : computation time [ sec] (upper) and the number of generated half-spaces (lower)

| ||||||
---|---|---|---|---|---|---|

| 5 | 7 | 9 | 11 | 13 | 15 |

50 | 0.34 | 0.15 | 1.23 | 11.25 | 72.05 | 391.27 |

566 | 5084 | 42,430 | 279,804 | 1,517,292 | 6,898,066 | |

100 | 0.04 | 0.42 | 8.41 | 107.85 | 1506.60 | – |

1326 | 16,382 | 229,218 | 2,399,099 | 25,526,149 | – | |

200 | 0.06 | 1.20 | 32.88 | 699.06 | – | – |

1970 | 42,918 | 851,321 | 13,002,403 | – | – | |

1000 | 0.15 | 7.44 | 394.21 | – | – | – |

6724 | 238,486 | 8,053,847 | – | – | – | |

2000 | 0.24 | 13.87 | 980.61 | – | – | – |

9262 | 427,048 | 17,550,631 | – | – | – |

### 3.2 Application of the V-representation to (P1) : to determine whether a new point is in the convex hull or not

Let *V*={**v**
_{1},…,**v**
_{
m
}} be a set of points in \(\mathbb {R}^{n}\). For (P1) in Section 2.1, i.e., the problem of determining whether \(\hat {\mathbf {v}} \in \text {conv}(V)\) or \(\hat {\mathbf {v}} \not \in \text {conv}(V)\), we have two approaches via H-representation and V-representation. In the approach via H-representation, after converting conv(*V*) to the linear inequalities **A**
**v**≤**b**, we need to check whether \(\mathbf {A}\hat {\mathbf {v}}\le \mathbf {b}\) or not. It is relatively easy to check \(\mathbf {A}\hat {\mathbf {v}}\le \mathbf {b}\), while the conversion is computationally intensive for not so large *m* and/or *n* as in Table 1. On the other hand, in the approach via V-representation, the linear programming (*abbr.* LP) method is available. At the end of this subsection, we will show that the approach via V-representation is much faster than the H-representation.

Fundamentally, LP can be regarded as an optimization problem, i.e., the problem of minimization or maximization of a linear objective function over a polyhedron. The simplex method and interior-point method are efficient algorithms to solve a LP problem or detect the infeasibility of the problem. In addition, linprog implemented in Optimization Toolbox offered by MathWorks and [6], are available as commercial software to solve LP problems. Refer to [3, 8], for more details on LP.

*V*) or not by solving the following LP problem:

**v**

_{1},…,

**v**

_{ m }is feasible in (1), we see that

Hence one can determine whether a new point \(\hat {\mathbf {v}}\) is in *P* or not by solving (1) instead of constructing **A**
**v**≤**b** for the H-representation of conv(*V*).

*V*of

*m*points in \(\mathbb {R}^{n}\) as Table 1. Here we generate \(\hat {\mathbf {v}}\in \,[\!-1, 1]^{n}\) randomly. We used linprog to solve all LP problems. Comparing Table 2 with Table 1, we see that the determination of \(\hat {\mathbf {v}}\in \text {conv}(V)\) via LP method is much faster in computation time than the conversion into the H-representation of conv(

*V*). This implies that the H-representation for (P1) will require more time to compute than the V-representation. For instance, in the case (

*m*,

*n*)=(1000,9), the same

*V*is used in Tables 1 and 2, and it spends 394.21 seconds to construct the H-representation of conv(

*V*), whereas it spends only 0.09 seconds to determine whether \(\hat {\mathbf {v}}\in \text {conv}(V)\) or not. Since we need to check \(\mathbf {A}\hat {\mathbf {v}}\le \mathbf {b}\) for the determination of \(\hat {\mathbf {v}}\in \text {conv}(V)\) via the H-representation, where

**A**and

**b**are constructed by the H-representation of conv(

*V*), the total amount of computation time via the H-representation is more than 394.21 seconds. Therefore, we can conclude from Tables 1 and 2 that the V-representation is less computationally intensive than H-representation.

Computation time [ sec] to determine whether a new point is in the convex hull or not by using LP method

| ||||||
---|---|---|---|---|---|---|

| 5 | 7 | 9 | 11 | 13 | 15 |

50 | 0.26 | 0.02 | 0.01 | 0.02 | 0.02 | 0.04 |

100 | 0.03 | 0.01 | 0.01 | 0.01 | 0.02 | – |

200 | 0.02 | 0.01 | 0.02 | 0.13 | – | – |

1000 | 0.02 | 0.03 | 0.09 | – | – | – |

2000 | 0.03 | 0.04 | 0.12 | – | – | – |

### 3.3 Application of the V-representation to (P2) : an optimization problem in the frame of MBC response surface methodology

*P*is the approximation of AOD by the convex hull for a set

*V*={

**v**

_{1},…,

**v**

_{ m }} of points in \(\mathbb {R}^{n}\), i.e.

*P*=conv(

*V*). Since any

**v**∈conv(

*V*) can be represented by a convex combination of

**v**

_{1},…,

**v**

_{ m }, the optimization (2) can be equivalently reformulated as

where \(\tilde {f}(\alpha _{1}, \ldots, \alpha _{m}) = f\left (\sum _{i=1}^{m} \alpha _{i} \mathbf {v}_{i}\right)\) and \(\tilde {g}_{j}\) is defined in a similar manner to \(\tilde {f}\).

- (I)
One can skip the process of constructing the H-representation of conv(

*V*). As we have already seen in Table 1, the conversion is computationally intensive, and thus one can greatly reduce the computational cost. - (II)
Since one does not apply the conversion of the V-representation of conv(

*V*) into the H-representation, the number of inequality constraints in (3) is much lower than (2) formulated by the H-representation. Consequently, the feasibility check of a generated solution in algorithms of optimization for (3) is much easier than (2). - (III)In contrast, the number of variables in (3) increases. In fact, it is
*m*, while for (2) is*n*, and thus the computational cost increases in one evaluation of a function value at a given solution. This is the disadvantage of the formulation (3). For instance, we will see in Table 3 that (2) formulated by the H-representation is more efficient than (3) for*n*=4.

To compare (3) with (2) formulated by the H-representation, we use a diesel engine data set. This data set consists of 875 observations and each measured observation consists of following nine engine measurements, i.e., Start of main injection event MAINSOI [ degCA], Common rail fuel-pressure FUELPRESS [MPa], Variable-geometry turbo charger [VGT], vane position VGTPOS [mm], Exhaust gas recirculation (EGR) valve opening position EGRPOS [ratio], Amount of injected fuel mass during main injection event MAINFUEL[mg/stroke], Mass-flow ratio of recirculated exhaust gas EGRMF [ratio], Air-Fuel ratio AFR [ratio], VGT rotational speed VGTSPEED [rpm], and in-cylinder peak pressure PEAKPRESS [MPa]. The measurements were performed at seven specific engine operating points, expressed as (Engine Speed SPEED [rpm], Brake Torque BTQ [Nm]) pairs.

- (A type)
BSFC

_{ p }(MAINSOI, FUELPRESS, VGTPOS, EGRPOS), - (B type)
BSFC

_{ p }(MAINSOI, FUELPRESS, VGTPOS, EGRPOS, MAINFUEL, EGRMF, AFR), and - (C type)
BSFC

_{ p }(MAINSOI, FUELPRESS, VGTPOS, EGRPOS, MAINFUEL, EGRMF, AFR, VGTSPEED, PEAKPRESS),

where *p*=1,…,7.

The dimension *n* of these data sets is 4,7 and 9, respectively. We considered different *n* in order to investigate the scalability of our proposed approach and to compare the computational cost with the H-representation of the convex hull.

*P*=conv(

*V*), and

*V*consists of a subset of the initial 875

*n*-dimensional vectors, since the approach we adopted is a point-by-point one. The measured points in each subset are unique. As an indication, each local model consisted of 125 of such measurements, and for each local model a corresponding convex hull was generated. Next, an optimization problem was considered. For this, we generate seven objective functions

*f*

_{ p }(for example using BSFC as the objective to be minimized) and do not use any extra constraint

*g*

_{ j }(

**v**)≥0 in this numerical experiment, except for the boundary model constraint itself. In particular, the objective functions

*f*

_{ p }are smooth but nonconvex, and thus it is a nonlinear optimization problem without the convexity. In conclusion, we have performed a point-by-point minimization problem for BSFC.

*P*. In this numerical experiment

^{2}, we use MBC Toolbox [10] and compare computation time of (3) with (2). The third and fourth columns in Table 3 are the computation time of the conversion of

*P*into the H-representation and the total of computation time for seven types of optimization, respectively. We do not describe the time in (3), but “–” in Table 3 because we do not convert

*P*into the H-representation. We used fmincon with interior-point algorithm implemented in Optimization toolbox of MATLAB to solve both (2) and (3). The optimization settings that were used to obtain the solution are listed in Table 4. For the settings not listed in Table 4 the defaults settings were used.

Optimization options used by fmincon

Maximum number of function evaluations | 5000 for H-rep. |
---|---|

20000 for V-rep. | |

Maximum number of iterations | 500 |

Maximum change in variables for finite-difference gradients | 0.1 |

Minimum change in variables for finite-difference gradients | 10 |

Step tolerance for free variables | 10 |

Constraint violation tolerance | 10 |

Objective function tolerance | 10 |

- (i)
In (A type) and (B type), i.e.,

*n*=4 and*n*=7, (2) formulated by the conversion of H-representation is faster than (3), whereas in (C type), (3) is approximately 2 times faster than (2). In fact, as we can expect form Table 1, the number of linear inequalities in (2) considerably increases. Consequently, the evaluation of computed solutions at each iteration becomes computationally intensive. - (ii)
The computation time of converting conv(

*V*) into the H-representation considerably increases as*n*increases. This can be also expected from Table 1. As (3) can skip this conversion, we can expect that (3) is more efficient than (2) for*n*≥9.

## Conclusion

We propose a way to reduce the computational cost in the approximation of the AOD via the convex hull. The H-representation of the convex hull is identified as the main bottleneck. We focus on the two processes in MBC and observe that the computational cost is greatly reduced when using the V-representation of a set of points instead of the H-representation. More precisely, when the dimension *n* of the space in which a set *V* of points lies is less than seven, the H-representation is not so computationally intensive. Otherwise it becomes more computationally intensive than the V-representation.

*V*) may be useful when the V-representation is applied to (P1) and (P2) described in Section 3. In fact, this is ensured by Krein-Milman’s theorem that for every bounded closed convex set

*A*,conv(

*A*)=conv(ext(

*A*)) holds. A simple way to enumerate all extreme points of conv(

*V*) is to solve the following LP problem for every

**v**

_{ k }∈

*V*:

If the optimal value is finite, then **v**
_{
k
} is not an extreme point in conv(*V*) because **v**
_{
k
} is a convex combination with other **v**
_{
i
} except for **v**
_{
k
}. Otherwise (4) is infeasible, and thus **v**
_{
k
} is an extreme point. This way is used as a pre-processing for (P1) and (P2). If conv(*V*) consists a few extreme points in comparison to the set *V*, then we can expect the improvement of performance for (P1) and (P2). See [11] for a much faster algorithm of the enumeration of all extreme points.

## Endnotes

^{1} The specification on the used computer is as follows: OS is Ubuntu 14.04, the CPU is Intel®; Xeon®; with 3.10GHz, and the memory is 128GB and version of MATLAB is R2015b.

^{2} The specification on the used computer is as follows: OS is Windows 7, the cpu is Intel®; Core™ i7 with 3.60GHz, and the memory is 32GB and version of MATLAB is R2015b.

## Declarations

### Acknowledgements

This article is based on discussion in workshops of the IMI Joint Research Projects “Research of Boundary Modeling” (Principal investigator : Satoru Watanabe) and “Research of Engine Calibration from the Viewpoint of Mathematical Science” (Principal investigator : Masahiro Satou). We would like to thank the participants in these workshops for a fruitful discussion and secretaries for hospitality. We would also like to thank Mr. Akira Ohata in Technova Inc. and Prof. Hiroyuki Ochiai in Kyushu University for significant comments to improve the presentation of this article.

**Open Access** This article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.

## Authors’ Affiliations

## References

- Assarf, B, Gawrilow, E, Herr, K, Joswig, M, Lorenz, B, Paffenholz A, Rehn, T: Computing convex hulls and counting integer points with polymake. Math. Prog. Comp. (2016). doi:10.1007/s12532-016-0104-z.
- Barvinok, A: A Course in Convexity. Graduate Studies in Mathematics, 54,Am. Math. Soc. Providence. (2002).Google Scholar
- Chvátal, V: Linear programming.W.H.Freeman & Co. Ltd., New York (1983).MATHGoogle Scholar
- Grünbaum, B: Convex Polytopes. Springer-Verlag, New York (2013).MATHGoogle Scholar
- Harada, S: Issues of MBC and boundary model of diesel engine development in Mazda. 2nd Workshop on Research of Boundary Modeling, held at Institute of Mathematics for Industry, Kyushu University. http://www.imi.kyushu-u.ac.jp/eng/events/view/787. Accessed 21 Dec 2016.
- IBM ILOG CPLEX Optimization Studio,. version 12. 6. 2. 0 https://www.ibm.com/developerworks/downloads/ws/ilogcplex/. Accessed 21 Dec 2016.
- Kieft, N, Linsen, R, Bäck, T: Evaluation of support vector machines as a design space description method in automotive applications. In: 6th Conference on Simulation and Testing for Automotive Electronics,pp. 123–139. Berlin (2014).Google Scholar
- Luenberger, DG, Ye, Y: Linear and Nonlinear Programming. Springer US, New York (2008).MATHGoogle Scholar
- Matt. J: Analyze N-dimensional Polyhedra in terms of Vertices or (In)Equalities. http://www.mathworks.com/matlabcentral/fileexchange/30892-representing-polyhedral-convex-hulls-by-vertices-or--in-equalities/content/vert2lcon.m. Accessed 21 Dec 2016.
- Model-Based Calibration Toolbox, MathWorks. http://www.mathworks.com/products/mbc. Accessed 21 Dec 2016.
- Pardalos, PM, Li, Y, Hager, WW: Linear Programming Approaches to the Convex Hull Problem in \(\mathbb {R}^{m}\). Comput. Math. Applic. 29(7), 23–29 (1995).MathSciNetView ArticleMATHGoogle Scholar
- Qhull. http://www.qhull.org. Accessed 21 Dec 2016.