1 Introduction
Engineering design has to rely on a number of contributing aspects: innovation, designing, geometry representation, computing, planning, and predetermination of product properties Conrad2004 . An important helper tool in this process is Computer Aided Design (CAD) software. CAD is utilized to convey design information from the designer to the manufacturer. As such, it has long ago replaced manual drawings. While the way geometry is represented within CAD systems has remained unaltered for decades now, the role of the CAD software in the design process has indeed changed. The trend certainly moves towards a more holistic design process, which includes also the steps of purchasing, manufacturing, and sales. Furthermore—at least within the research community—CAD systems have become closely intertwined with analysis and optimization steps.
Given the importance of CAD software, we will now repeat the key ideas of geometry representation within this context. A type of geometry representation common to most CAD systems are splines and in particular NonUniform Rational Bsplines (NURBS). As illustrated in Rogers2001 , the success of this spline type in CAD goes back to Versprille Versprille:1975aa as well as Tiller and Piegl Tiller:1983aa ; Piegl1987 . As a member of the category of parametric geometry representations, NURBS can easily represent multivalued functions. Further, they feature a high level of smoothness and differentiability. They are invariant under affine transformations and provide local control over geometry. Finally, they are able to represent freeform shapes and—in the engineering context so important—conic sections Rogers2001 . Common exchange formats for NURBS are IGES Smith:1986sm or STEP pratt2001introduction .
In 2005, Hughes et. al introduced the concept of isogeometric analysis (IGA). Here, the key idea is the use of spline functions as interpolation functions for the unknown solution in a finite element context. Originally conceived to bridge the gap between CAD and analysis, the concept soon proved to be advantageous also solely from the analysis point of view. As detailed in
Cottrell2009, key advantages of the IGA approach are: (1) exact (as in CADconforming) geometry representation; (2) usercontrolled smoothness and continuity of the basis; (3) in general higher accuracy per degree of freedom; (4) in general variation diminishing property. IGA has been applied to many different fields, including phase field methods for the CahnHilliard equations
Gomez2008 , brittle fracture Borden2012 , topology optimization Dede2012 , or fluidstructureinteraction Hsu2012 ; Hosters2018 .Another field of research that can profit largely from spline representations is shape optimization. Here, a geometry representation based on splines not only ensures easy incorporation into the standard design and manufacturing process, but also provides a means to include shape constraints into the parameterization. Shape optimization with splines in the form of freeform deformation is for example demonstrated in salmoiraghi2018free , spline boundary representations are utilized in hirschler2018isogeometric ; herrema2017framework ; lian2016implementation ; fusseder2015fundamental ; kostas2015ship .
In view of the requirements of CAD, IGA, and shape optimizations, the aim of this work is to propose an open source C++ spline library. One question the reader might ask at this point is: “Where is the need for yet another spline library?”. Naturally, we are aware of the manifold spline libraries relying on a variety of programming languages and licensing concepts. However, these libraries usually focus on one specific application. In contrast, this library aims to be applicable to all three application areas mentioned above.
The predecessor of the proposed library was an inhouse development written in FORTRAN. It was essential in a variety of scientific publications, addressing shape optimization and IGA within the context of numerical flow simulations (e.g., siegbert2013design ; siegbert2015individualized ). However, it turned out that there is a high demand for a multipurpose spline library in the scientific computing community. Therefore, the development of a new C++ spline library was published as open source project under the LPGL3 license. All experiences made while developing the FORTRAN library were used to improve the new development.
Besides a wide range of different functionality, also requirements regarding programming language, build system, and supported computer systems were taken into account. The proposed spline library is fully written in modern C++, a programming language increasingly replacing FORTRAN in the scientific community. We point out that it is easily possible to couple C++ code to other scientific programming languages like Python or FORTRAN. With the intention of developing a stateoftheart library, the most recent C++17 standard is used. As a result, the library can make use of modern object oriented designs; but the recent standard also requires a recent compiler. However, almost every system can be equipped with a recent Clang, GCC, or Intel compiler.
As build system, CMake Kitware:2012 is used. This system is available for most highperformance computing (HPC) machines. However, on HPC machines it is crucial to install software with all its dependencies. The more dependencies a software package requires, the more complicated the installation becomes. Fortunately, Gamblin et. al. Gamblin:2015aa made a great effort in the last years to develop Spack as a dependency manager for scientific software. The proposed software library comes with support for Spack. Therefore, installation of the library and all its dependencies is quite simple. That makes the software usable for a wide range of scientists without caring about dependencies.
To maintain a high software quality, SplineLib is tested by means of the Google testing framework Civil:2013 . This is combined with continuous integration and a test coverage that is in the area of 100%. The resulting number of tests simultaneously serves as a set of examples on how to use the library. There is no need to read a large documentation. Instead, the user can look for a test case suitable to the application at hand.
The paper provides an overview over the main features and implementational constituents of SplineLib. It concludes with two basic sample test cases from the area of IGA and shape optimization.
2 Splines
This section gives a brief introduction into the definition of splines. A detailed description of splines—as well as corresponding properties and algorithms—can be found in Piegl:2012aa .
In general, splines map from a parametric space to a physical space. Let there are basis functions defined in the parameter space. In the dimensional physical space , a control point is associated with each basis function. A parametric coordinate is mapped to the physical space by (1) evaluating each basis function at ; (2) multiplying these values with the corresponding control points; (3) summing up all products:
The definitions of the various spline types differ in the way the parametric space and the basis functions are defined. SplineLib currently supports Bsplines and the related NURBS, but implementation of further spline techniques is envisaged. From the class of these splines, solely the socalled clamped splines are considered. Clamped splines are those that interpolate their boundary control points exactly.
For simplicity, the current description is restricted to onedimensional splines as higher dimensional splines (surfaces, volumes, etc.) are constructed by using tensor products of onedimensional splines. In contrast, the software library at hand supports splines of arbitrary dimension because the parametric dimensionality is implemented as a template parameter.
The parametric space is defined by a knot vector
. A knot vector is a nondecreasing sequence of real numbers (potentially nonuniformly spaced):where is called a knot. Based on the knot vector , the th knot span is defined as:
(1) 
A knot span is called nonzero if . Given these knot spans, the Bspline basis functions are defined from basis functions of degree zero by using the Coxde Boor recursion formula:
(2) 
The number of control points for a spline of degree is given as
Note that the fraction can occur in Eq. (2) if a knot vector contains the same knot times. This ratio is defined to be zero:
Given these basis functions, a th degree Bspline curve can be written as
(3) 
It is wellknown that Bsplines have their limitations if geometries become more complex. For example, it is not possible to exactly represent a circle by a Bspline curve. NURBS overcome this limitation Versprille:1975aa ; Tiller:1983aa . In contrast to Bsplines, NURBS map to a weighted physical space. Utilizing the Bspline basis functions, a NURBS curve is defined as
(4) 
where are the weights assigned to the control points. Introducing
Eq. (4) can be rewritten as
This form resembles the Bspline definition in Eq. (3) with the exception of the definition of basis functions.
In the spline library both types of splines can be accessed by a common spline interface. This allows for a splinetype independent code development. Even new spline types as for example Tsplines or PBsplines can be used without any relevant modifications if they are implemented within a later release of the software.
3 Implementation: Evaluation of BSpline Basis Functions
There are manifold ways in which Eq. (2) can be translated into a computer algorithm. Two key issues to keep in mind are possible repetitive evaluations of individual components and the occurrence of zero values in the denominator.
A commonly used and very efficient procedural algorithm for evaluating the Bspline basis functions is considered in Piegl:2012aa . In contrast to such procedural algorithms, the algorithm proposed here benefits from an objectoriented approach. Its design is based on the idea of reflecting the evaluation procedure in a data structure. Furthermore, it only checks once for zero denominators. The key ideas are outlined in the next two sections.
3.1 Data Structure for BSpline Basis Functions
Reviewing the definition of the Bspline basis functions in Eq. (2) gives rise to the present design idea illustrated in Fig. 1: There are two types of Bspline basis functions that need to be distinguished, viz., of degree and of degree . The former are jump functions. Instead, evaluating the th Bspline basis function of degree requires a linear combination of the two basis functions and .
An abstract base class BasisFunction defines the common interface of Bspline basis functions of arbitrary degree . The basis function is characterized by its degree_ and its support specified by start_knot_ and end_knot_. The support starts with the th knot span (cf. Eq. (1)) and covers knot spans. Therefore, it is usually given as . In the special case that equals the last knot of the knot vector , must be included in the support (cf. second case of Eq. (1)). Thus, the support is given as if end_knot_is_last_knot_ is set to true during the construction of an object of type BasisFunction.
Both ZeroDegreeBSplineBasisFunction and BSplineBasisFunction derive from this abstract class. The former implements a step function whose support is a single knot span. It represents the base case of the recursion. The latter takes the linear combination in the Coxde Boor recursion formula Eq. (2) into account by storing pointers to objects of the basis functions of lower degree and in left_lower_degree_ and right_lower_degree_, respectively. As the associated denominators only depend on the knot vector, they do not change for a specific BSplineBasisFunction. Hence, their adequately inverted values are computed during construction using InvWithPosZeroDenom and stored in left_denom_inv_ and right_denom_inv_.
When the factory function CreateDynamic is called with a knot vector kv, a knot span start_support (corresponding to the start of the basis function’s support), and a degree deg, the object hierarchy is constructed. An object of type ZeroDegreeBSplineBasisFunction or BSplineBasisFunction is created depending on whether deg is equal to zero or not. Within the constructor of BSplineBasisFunction, the two objects for both lower degree Bspline basis functions are instantiated.
The Bspline basis functions’ derivatives of arbitrary degree can also be computed by linearly combining corresponding derivatives of lower order Bspline basis functions. Therefore, the proposed data structure is also wellsuited for computing derivatives of arbitrary degree.
3.2 Evaluation Algorithm
The methods Eval or EvalDeriv of a BSplineBasisFunction evaluate the function or its derivatives of arbitrary degree deriv at a parametric coordinate pc, respectively. Within those two, IsCoordInSup is called to check if pc is contained in the support of the BasisFunction object. If the parametric coordinate is not contained in the support, evaluating the functions and their derivatives yields zero. Otherwise, EvalOnSup or EvalDerivOnSup are called. Their actual implementations are provided by ZeroDegreeBSplineBasisFunction and BSplineBasisFunction.
Since ZeroDegreeBSplineBasisFunction is a jump function, it evaluates on its support simply to one while all derivatives are equal zero. In contrast, evaluating a BSplineBasisFunction involves two nontrivial ingredients (cf. Eq. (2)): First, computing both fractions; second, evaluating the lower degree Bspline basis functions and . The two fractions are computed by calling CompLeftQuot and CompRightQuot. Each method utilizes start_knot_ or end_knot_ to evaluate the numerator. Next, its product with the values of the inverted denominator stored in left_denom_inv or right_denom_inv is computed. These results are then multiplied with the values of the lower degree functions—accessed through left_lower_degree_ and right_lower_degree_—and, finally, added.
4 SplineLib Features
This section describes the main utility functions of SplineLib: Input/Output and spline manipulation. Again, the multipurpose idea has been emphasized.
4.1 Input and Output
SplineLib supports the four different file formats ITD, IGES, VTK and XML. ITD is the native file format used in IRIT. The application IRIT is a freeform geometric modeling environment developed by Elber Irit15 . It supports modeling of rational and nonrational Bspline curves, surfaces, and trivariate volumes. The latter is a feature almost unique to IRIT. In the past, IRIT has been utilized in connection with IGA antolin2019isogeometric ; antolin2019optimizing ; massarwi2016b .
A similar format to ITD is based on Extensible Markup Language (XML). The XMLtype data format for storing spline geometrical and related data was native to the FORTRAN library developed at the Chair for Computational Analysis of Technical Systems. The XML format stores splines of arbitrary degree and dimension. It was mainly developed in an IGA context. Therefore, it can be used to store the spline geometry together with additional data. The data can be defined as element data or control point data. For practical reasons, it is only implemented for dimensions up to four. This allows for typical threedimensional computations as well as fourdimensional spacetime computations, where time is handled as additional dimension. However, SplineLib can easily be extended to support higher dimensions. Parsing and writing XML files is built on top of the opensource library pugixml pugixml .
Initial Graphics Exchange Specification (IGES) Smith:1983aa is another file format that allows the digital exchange of geometry information among CAD systems. The IGES format was introduced in 1979 and became the standard for transferring multidimensional models between CAD programs. Although there are newer formats nowadays, it is still widely used. Therefore, supporting IGES enables SplineLib to import and export data, that is relevant in industry. IGES itself supports not only spline geometries, but also other types of data. These are for example color information, meshes, and polylines. The SplineLib implementation, however, focuses on NURBS and Bspline curves and surfaces. All other IGES entries are ignored.
For postprocessing data from computational fluid dynamics, an often used tool is Paraview Ahrens:2005aa
. Paraview is an opensource software for data visualization and analysis. It is built on top of the Visualization Toolkit (VTK)
Schroeder:1999aa . VTK provides its own file format. Although it cannot represent splines, they can be visualized by converting them into a mesh. As meshes cannot be transformed back into splines, SplineLib only provides a VTK writer and no reader. This writer can be used to convert data obtained by SplineLib into mesh data for visualization and analysis. The SplineLib API provides the user with the possibility to decide on the resolution of the mesh. Thus, it can be adjusted to the relevant data. The VTK export does not only convert the geometry, but can also add further element or control point data to the VTK file. As a result, this exporter can be used to visualize data obtained by optimization or IGA with the welldeveloped tools for postprocessing.SplineLib also provides an interface to convert data between these different formats. This functionality closes the gap between the different application areas.
4.2 Spline Manipulation
In addition to the support of multiple file formats, the second main feature implemented in SplineLib are the two most fundamental geometric algorithms for splines: (1) knot insertion/removal, and (2) subdivision.
Knot insertion is a means of improving the local control of the spline properties. Key to knot insertion is that it only acts on the parametric representation: It is important that the global geometry of the spline remains unaltered. In order to achieve this, new control points need to be inserted and others repositioned. The algorithm in SplineLib has been adapted from Piegl:2012aa . In particular, the adaption concerns the spline dimension, which in SplineLib is implemented as template parameter.
In a similar fashion, knots can be removed. Note that in contrast to knot insertion—depending on the specific scenario—knot removal may not be possible without altering the spline geometry. In those cases, deviations (in terms of Euclidean distance) of the altered spline from the original one are bounded by a userspecified tolerance.
One particular extension of knot insertion is spline subdivision. It relies on inserting the same knot repeatedly, until continuity is reached. At this point, the splines can be separated by splitting the original knot vector. Also this algorithm has been extended to arbitrary dimension.
5 Application Examples
This final section is devoted to two application examples: IGA and optimization.
5.1 Iga
In order to demonstrate the applicability of SplineLib to solve partial differential equations (PDEs) using IGA, we consider Poisson’s equation. The general boundary value problem is given as:
with unknown function , source term , the computational domain with boundary and constants , , and some function . In the following, we restrict ourselves to homogeneous Dirichlet boundary conditions ( and ). Furthermore, we assume a constant source term of . The weak form is obtained by multiplication of the PDE with an arbitrary weighting function and integration over the computational domain . Following Galerkin’s method, the same function space is used for both the solution candidate and the weighting function. The finitedimensional subspace is represented by the spline basis function. Considering the rational basis function , the discrete weak form reads
Note in particular that this approach uses the isoparametric principal, where the same basis functions are used for geometry representation and analysis. Elementwise integration, i.e., integration on tensorproducts of nonzero knot spans, by means of Gaussian quadrature then leads to
where denotes the element number, the integration points, and the indices of the nonzero basis functions and are the integration weights. The resulting linear equation system is solved using Armadillo sanderson2016armadillo ; sanderson2018user , an opensource linear algebra library. More details on the formation of the linear equation system and IGA in general are provided in Hughes:2005 .
The IGA framework based on SplineLib distinguishes itself from other IGA codes by the implementation of the parametric dimensionality of the spline as template parameter. Thereby, the user is enabled to solve PDEs on splines of arbitrary dimensionality using the same code.
The functionality of the IGA framework was verified using analytical solutions provided in elman and solutions computed using finite element solvers. To demonstrate the capability to compute solutions for problems of higher dimensionality, the solution of the given reference problem is approximated inside the unit cube . This problem is equivalent to finding the temperature distribution inside a cube with uniform heating and faces that are kept at zero temperature. To visualize the solution, three slices through the cube are created normal to the ,  and axis. These slices are shown in Fig. 2. The temperature distribution is equal on all slices and is equal to the solution that would be obtained for the same boundary value problem on the square plate . The highest temperature is reached in the center of the cube and decreases when getting closer to the boundary of the cube. The temperature distribution is spherically symmetric.
The IGA framework in SplineLib can certainly also be used for much more complex geometries. A simple example is used here, since the exact solution of this problem can be represented using a series expansion. This is not the case for complex geometries.
5.2 Optimization
A simple shape optimization problem is considered to demonstrate the value of SplineLib’s functionalities. The shape to optimize is a seconddegree Bspline curve with the following properties: The knot vector is given as
and the shape is represented by the three twodimensional control points
where is the design variable for the optimization. The design variable is subject to a bound constraint by . The initial value is . How to construct (as well as evaluate) this initial spline is shown in Fig. 3 (further examples can be found at https://github.com/mfcats/SplineLib/tree/master/example).
The target shape is a parabola given as
Thus, the objective function is the area between the Bspline and the parabola on the interval .
To solve this simple optimization problem, an executable using SplineLib evaluates the objective function for a given control point coordinate . This objective function is coupled to the optimization framework Dakota Adams:2018aa . The gradientfree COBYLA algorithm is applied to the optimization problem. For visualization purposes, VTK output is used. The result of each optimization step is written into a single VTK file.
The result is shown in Fig. 4. The solution converges to the target shape within 32 iterations.
With this example the application of SplineLib in an optimization environment is shown. Due to the amount of supported input and output formats it is a straightforward step to use SplineLib also in more complex and realworld applications.
6 Conclusion
A new multipurpose C++ spline library is presented. The aim of the library is to close the gap between different research fields. Therefore, interfaces to commonly used file formats are provided. With being able to represent not only curves and surfaces, but also splines of higher dimensions, SplineLib can be used in many applications. For the evaluation of basis functions and their derivatives, a newly developed algorithm is facilitated. In this algorithm, the procedural approach of evaluating the basis functions is realized as a data structure. The main application areas SplineLib aims to connect are CAD, IGA, and optimization. How to use SplineLib in these areas is shown in simple application examples.
From this initial state, it is necessary to further develop SplineLib. It is required to make SplineLib more powerful, e.g., by supporting recent spline techniques and incorporating elaborate algorithms. Here, we welcome the input of the community via GitHub (https://github.com/mfcats/SplineLib).
Acknowledgements
The authors gratefully acknowledge the support of Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) under the Collaborative Research Center SFB 1120, subproject B2, the Cluster of Excellence “Integrative Production Technology for HighWage Countries” EXC 128, and the International Research Training Group “Modern Inverse Problems” 33849990/GRK2379.
Bibliography
References

[1]
B. M. Adams, L. E. Bauman, W. J. Bohnhoff, K. R. Dalbey, M. S. Ebeida, J.P.
Eddy, M.S. Eldred, P.D. Hough, K.T. Hu, J.D. Jakeman, J.A. Stephens, L.P.
Swiler, D.M. Vigil, and T.M. Wildey.
Dakota, a multilevel parallel objectoriented framework for design optimization, parameter estimation, uncertainty quantification, and sensitivity analysis: Version 6.8 theory manual.
Technical report, Sandia Technical Report SAND20144253, 2018.  [2] James Ahrens, Berk Geveci, and Charles Law. Paraview: An enduser tool for large data visualization. The visualization handbook, 717, 2005.
 [3] Pablo Antolin, Annalisa Buffa, Elaine Cohen, John F Dannenhoffer, Gershon Elber, Stefanie Elgeti, Robert Haimes, and Richard Riesenfeld. Optimizing microtiles in microstructures as a design paradigm. ComputerAided Design, 2019.
 [4] Pablo Antolin, Annalisa Buffa, and Massimiliano Martinelli. Isogeometric analysis on vreps: first results. arXiv preprint arXiv:1903.03362, 2019.
 [5] M.J. Borden, J. Michael, C.V. Verhoosel, M. Scott, T. J.R. Hughes, and C. Landis. A phasefield description of dynamic brittle fracture. Computer Methods in Applied Mechanics and Engineering, 217:77–95, 2012.
 [6] Gennadiy Civil. googletest. https://github.com/abseil/googletest, 2018.
 [7] K.J. Conrad, editor. Taschenbuch der Konstruktionstechnik. Fachbuchverlag Leipzig, 2004.
 [8] J. A. Cottrell, T. J. R. Hughes, and Y. Bazilevs. Isogeometric Analysis: Toward Integration of CAD and FEA. John Wiley & Sons, Ltd, 2009.
 [9] L. Dedè, M.J. Borden, and T.J.R. Hughes. Isogeometric Analysis for Topology Optimization with a Phase Field Model. 19:427–465, 2012.
 [10] Howard C Elman, David J Silvester, and Andrew J Wathen. Finite elements and fast iterative solvers: with applications in incompressible fluid dynamics. Numerical Mathematics and Scientific Computation, 2014.
 [11] Daniela Fußeder, Bernd Simeon, and AV Vuong. Fundamental aspects of shape optimization in the context of isogeometric analysis. Computer Methods in Applied Mechanics and Engineering, 286:313–331, 2015.
 [12] Todd Gamblin, Matthew LeGendre, Michael R. Collette, Gregory L. Lee, Adam Moody, Bronis R. de Supinski, and Scott Futral. The spack package manager: Bringing order to hpc software chaos. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis, SC ’15, pages 40:1–40:12, New York, NY, USA, 2015. ACM.
 [13] Héctor Gómez, Victor M Calo, Yuri Bazilevs, and Thomas JR Hughes. Isogeometric analysis of the cahn–hilliard phasefield model. Computer methods in applied mechanics and engineering, 197(4950):4333–4352, 2008.
 [14] Austin J Herrema, Nelson M Wiese, Carolyn N Darling, Baskar Ganapathysubramanian, Adarsh Krishnamurthy, and MingChen Hsu. A framework for parametric design optimization using isogeometric analysis. Computer Methods in Applied Mechanics and Engineering, 316:944–965, 2017.
 [15] Thibaut Hirschler, Robin Bouclier, Arnaud Duval, Thomas Elguedj, and Joseph Morlier. Isogeometric sizing and shape optimization of thin structures with a solidshell approach. Structural and Multidisciplinary Optimization, pages 1–19, 2018.
 [16] Norbert Hosters, Jan Helmig, Atanas Stavrev, Marek Behr, and Stefanie Elgeti. Fluid–structure interaction with nurbsbased coupling. Computer Methods in Applied Mechanics and Engineering, 332:520–539, 2018.
 [17] MingChen Hsu and Yuri Bazilevs. Fluid–structure interaction modeling of wind turbines: simulating the full machine. Computational Mechanics, 50(6):821–833, 2012.
 [18] T.J.R. Hughes, J.A. Cottrell, and Y. Bazilevs. Isogeometric analysis: CAD, finite elements, NURBS, exact geometry and mesh refinement. Computer Methods in Applied Mechanics and Engineering, 194(39):4135 – 4195, 2005.
 [19] Irit. Irit 11.0 user’s manual. http://www.cs.technion.ac.il/$∼$irit, 2015. Technion.
 [20] Arseny Kapoulkine. pugixml. https://pugixml.org, 2018. [Online; accessed 31May2019].
 [21] Kitware, Inc. CMake. http://cmake.org, 2012.
 [22] KV Kostas, AI Ginnis, CG Politis, and PD Kaklis. Shiphull shape optimization with a tspline based bem–isogeometric solver. Computer Methods in Applied Mechanics and Engineering, 284:611–622, 2015.
 [23] Haojie Lian, Pierre Kerfriden, and Stéphane PA Bordas. Implementation of regularized isogeometric boundary element methods for gradientbased shape optimization in twodimensional linear elasticity. International Journal for Numerical Methods in Engineering, 106(12):972–1017, 2016.
 [24] Fady Massarwi and Gershon Elber. A bspline based framework for volumetric object modeling. ComputerAided Design, 78:36–47, 2016.
 [25] L. Piegl and W. Tiller. Curve and surface constructions using rational bsplines. CAD, 19:485–498, 1987.
 [26] Les Piegl and Wayne Tiller. The NURBS book. Springer Science & Business Media, 2012.
 [27] Michael J Pratt. Introduction to iso 10303—the step standard for product data exchange. Journal of Computing and Information Science in Engineering, 1(1):102–103, 2001.
 [28] D.F. Rogers. An Introduction to NURBS with Historical Perspective. Morgan Kaufmann Publishers, 2001.
 [29] Filippo Salmoiraghi, Angela Scardigli, Haysam Telib, and Gianluigi Rozza. Freeform deformation, mesh morphing and reducedorder methods: enablers for efficient aerodynamic shape optimisation. International Journal of Computational Fluid Dynamics, 32(45):233–247, 2018.
 [30] Conrad Sanderson and Ryan Curtin. Armadillo: a templatebased c++ library for linear algebra. Journal of Open Source Software, 1(2):26, 2016.
 [31] Conrad Sanderson and Ryan Curtin. A userfriendly hybrid sparse matrix class in c++. In International Congress on Mathematical Software, pages 422–430. Springer, 2018.
 [32] Will Schroeder, Kenneth M Martin, LS Avila, and CC Law. The VTK user’s guide. Kitware, 1999.
 [33] Roland Siegbert, Stefanie Elgeti, M Behr, K Kurth, C Windeck, and Ch Hopmann. Design criteria in numerical design of profile extrusion dies. In Key Engineering Materials, volume 554, pages 794–800. Trans Tech Publ, 2013.
 [34] Roland Siegbert, Nafi Yesildag, Markus Frings, Frank Schmidt, Stefanie Elgeti, Henning Sauerland, Marek Behr, Christian Windeck, Christian Hopmann, Yann Queudeville, et al. Individualized production in diebased manufacturing processes using numerical optimization. The International Journal of Advanced Manufacturing Technology, 80(58):851–858, 2015.
 [35] Brad Smith and Joan Wellington. INITIAL GRAPHICS EXCHANGE SPECIFICATION (IGES), VERSION 3.0. 1986.
 [36] Bradford M Smith and Joan Wellington. Iges, a key interface specification for cad/calm systems integration. ComputerAided Geometry Modeling, page 279, 1983.
 [37] W. Tiller. Rational bsplines for curve and surface representation. IEEE Computer Graphics and Applications, 3:61–69, 06 1983.
 [38] Kenneth James Versprille. Computeraided design applications of the rational Bspline approximation form. PhD thesis, Syracuse University, 1975.
Comments
There are no comments yet.