Keywords

These keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

1 Introduction

Non-uniform rational B-spline (NURBS) is the standard mathematical representation for geometry in most commercial computer aided design (CAD) software. Finite element analysis (FEA) has been widely used in most commercial computer aided engineering (CAE) software. Geometry designed in CAD software must undergo an approximating discretization process known as meshing, so that it can be used for analysis in CAE software. A seminal effort to integrate CAD and CAE, termed isogeometric analysis (IGA) [1], gained great attention as a new “design-through-analysis” methodology. It enabled direct analysis of the designed geometry without meshing.

T-spline [2] was introduced as a generalization of NURBS allowing local refinement. The introduction of the Autodesk T-Splines Plugin for Rhino in 2004 (http://www.tsplines.com/) provides designers the tool to create and manipulate T-spline geometries. T-spline basis functions have been incorporated into IGA [3], further generalizing the “design-through-analysis” framework. Analysis-suitable T-splines in IGA were characterized [4], and various methods were developed to construct volumetric T-splines for IGA [5–9]. Open-source NURBS based IGA implementations [10, 11] were introduced, but they are primarily used in research. Recent efforts have increased accessibility of T-spline based IGA to industry. Data structures for T-spline based IGA were developed [12, 13]. Moreover, NURBS based IGA was implemented in Abaqus [14]. Although the improvements of IGA are vast, it is still at the beginning stage in industry. So far, T-spline based IGA implementations have not yet been available in many commercial software like Abaqus.

In this chapter, we present a novel CAD-CAE software framework for T-spline based IGA. Since Rhino and Abaqus are built for engineering design and analysis specifically, here we develop a T-spline based IGA software framework upon them. Users can benefit from the strengths of both software. This framework allows:

  • Boundary value problem (BVP) specification on T-spline geometry;

  • Volumetric T-spline construction from surface representation;

  • Efficient and compact trivariate T-spline data structure; and

  • Abaqus T-spline IGA user element subroutine based on Bézier extraction.

The reminder of this chapter is organized as follows. Section 1 overviews the framework and the pipeline. Section 3 describes surface T-spline geometry creation and BVP specification. Section 4 presents T-spline data structure. Section 5 explains how volumetric T-splines are constructed from surface T-splines. Section 6 presents our T-spline Abaqus user subroutine. Finally, section 7 shows numerical results and draws conclusions.

2 Software Framework and Pipeline Overview

To integrate Rhino with Abaqus, the framework uses Rhino with the T-spline plugin to create and manipulate T-spline geometries, and uses Abaqus for analysis through its user element subroutines (UEL/UELMAT). The framework incorporates two self-developed plugins as shown in Fig. 1, the Rhino plugin in the grey and blue blocks and the Abaqus plugin in the red block. This framework requires the following software environment:

  • Rhinoceros 3D, Version 5 or newer;

  • Autodesk T-splines Plugin for Rhino, Version 3.4 or newer;

  • SIMULIA Abaqus Unified FEA, Version 6.0 or newer; and

  • Intel FORTRAN, Version 11 or newer.

Fig. 1
figure 1

Rhino 3D to Abaqus Software Pipeline Overview.

Full size image

As shown in Fig. 1, surface geometry is created in Rhino first. With the Rhino plugin, BVP problem is specified and the geometry is pre-processed, ending up with Abaqus input files. Depending on whether a 2D or 3D geometry is needed, users can choose whether to construct volumetric T-splines. For a 2D case, a Rhino.iga file is directly converted into Abaqus.inp file and.bezier file. For a 3D case,.TSM files are saved and converted to our.STSP file for volumetric T-spline construction, and then Abaqus.inp file and.bezier file are generated for analysis. When the analysis is completed through the Abaqus plugin, a post-processing function is called in the Abaqus plugin to generate the.odb file for visualization. Based on the results, the user can go back to Rhino to refine or modify the geometry.

3 Geometry Generation and BVP Specification

Our software framework supports both surface and volumetric T-splines. Since Rhino only supports surface modeling, surface T-splines must undergo a conversion process to become volumetric T-splines. Currently, we support two types of volumetric T-spline geometries. The first type is a 3D geometry created by sweeping a surface T-spline patch, and the second type is the geometry with genus-zero cube topology which can be created using the conformal parametric mapping method[7]. Fig. 2 shows three T-spline surface models designed in Rhino. (a) and (b) show 2D open surfaces which can be used in analysis directly or converted to volumetric T-spline via sweeping. (c) shows a structure with genus-zero topology and six patches, which can be converted into volumetric T-spline via parametric mapping.

Fig. 2
figure 2

(a) A 2D quarter of a plate with a hole; (b) a 2D notch structure prepared for sweeping; and (c) a quarter cylinder with genus-zero cube topology.

Full size image

In Rhino, all the boundary conditions are applied on relevant control points. In the pre-processing step, the Rhino plugin extracts the information of these control points and writes to Abaqus.inp file. To apply boundary conditions, we use the T-Spline plugin selection node sets [15] to choose desired control points. The platform is currently limited to specifying Dirichlet boundary conditions, but extending to other boundary conditions is straightforward. For the material properties, simple isotropic material properties are supported currently. The users can specify the Young’s Modulus E and the Poisson’s Ratio ν.

4 T-Spline Data Structure

In this section, we first explain the commercial .TSM data structure used in Rhino. Then, we introduce our .STSP/.VTSP data structure and explain the conversion between them.

4.1 TSM Data Format

The .TSM file originated from “half edge” data structure[13] which contains parametric and physical information of a T-spline control mesh (T-mesh). Fig. 3(a) shows three representative faces or elements of a T-mesh. F 1 is a corner face, F 2 is an edge face, and F 3 is an interior face. Fig. 3(b) takes a corner face as an example to show detailed components in a .TSM face, including links, vertices, grips, faces, and edges.

Fig. 3
figure 3

(a) A T-mesh with three representative faces/elements, the corner face F 1, the edge face F 2, and the interior face F 3; (b) a corner face in .TSM data format. Abbreviations are: l-link, v-vertex, g-grip, F-face, e-edge; and (c) a corner element in .STSP data format. Abbreviations are: AC-Associate Corner, DI-Duplicated Node Index, DN-Duplicated Node, F- Element, L-Parametric Length, RL-Relative Location, RN-Regular Node, TJ-T-Junction.

Full size image

Link {previous, next, opposite, vertex, face, edge, type}. Links tie the topology of a surface together. Every edge, face, or vertex refers to a link to determine its location. The first 3 values indicate the id of the previous, next, and opposite links. For example, in Fig. 3(b), the previous, next, and opposite links of l 5 are l 9, l 6, and l 0, respectively. Each link has an associated vertex, face, and edge which are the three values following the opposite link. For example, l 5 originates from v 0 and belongs to F 1, associating to e 0. The type indicates what kind of node the link starts from, either a regular node (Type 0), a T-junction (Type 1), or an L-junction (Type 2). For example, the type of l 5 is 0 since it starts from a regular node while the type of l 8 is 1 since it starts from a T-junction. Note that the T-junction can break one edge into multiple links. Here, the T-junction g 8 breaks the edge e 2 into l 7 and l 8.

Vertex {link, direction}. A vertex is the origin of a link. The direction that the link points away from the vertex is stored as one of the North (N), South (S), East (E), and West (W). For example, v 0, v 1, v 2, and v 3 are four vertices of the corner face F 1 in Fig. 3(b).

Grip {x, y, z, weight}. A grip, equivalent to a control point, is defined by its x, y, z coordinates and weight. A grip may be parent of one or more other grips. This kind of grips is also known as compound grips. For example, in Fig. 3(b), g 0 is a compound grip which is the parent of g 4, g 5, and g 6.

Face {start link, flag}. A face is used to represent an element in the T-mesh, and it is defined by a start link and a flag. The connectivity of a face is given by the counter-clockwise cycle of links at its borders, starting from its start link. The flag of a face stores various properties of this face like if the face is hidden or not.

Edge {link, interval}. An edge connects vertices in the T-mesh. It is defined by a link and an interval. Its link is one of the two links running along it, while the “interval” is its parametric length.

4.2 STSP/VTSP Data Format and Conversion

Let us first define four types of control points for our T-spline data structure, including the regular node, the duplicated node, the T-junction node, and the extraordinary node. A regular node is a control point with valence 4. A duplicated node is a duplication of its neighbor, see the green dots in Fig. 3(c). A T-junction is a control point that is analogical to the hanging nodes in classical finite elements, see the orange dot. For T-junction nodes, we record the edge it locates as well as its index. An extraordinary node is an interior control point with valence other than 4, and not a T-junction. In our data structure, regular node, T-junctions, and extraordinary nodes are used to describe the connectivity of elements. Regular nodes are often the parents of duplicated nodes. A corner regular node is the parent of three duplicated nodes while a boundary regular node is the parent of one duplicated node. For example, in Fig. 3(c), RN 1 is the parent of DN 1, DN 2, and DN 3, and RN 2 is the parent of DN 4. According to the algorithm introduced in [16], extraordinary nodes cannot be the parents of duplicated nodes.

The .STSP/.VTSP data structure is efficient in storing surface and volumetric T-spline information. This data structure is designed especially for the convenience of extracting knot vectors. It is compact, concise, and easy to interpret and fit into the commercial software. Our data format contains two types of data, the control point data and the element data. The former contains the basic information of T-spline control points, and the latter contains connectivity, parametric length, T-junctions, and duplicated nodes in the element.

  1. 1.

    Control Point {x, y, z, weight, type}. A control point is defined by its x, y, z coordinates, weight, and type. For the type, we use 0 to represent the regular node, 1 for duplicated node, 2 for T-junction node, and 3 for extraordinary node.

  2. 2.

    Element {Corner ID 1−4 , Parametric Length 1−2 , T-junction ID 1−4 , Number of Duplicated Nodes, (Duplicated Node ID, Associated Corner, Relative Location) 1−totalnumber }. The first four values are the indices of the four corners of this element. The next two values specify the parametric length of the edges. The following four values are the T-junction indices for each edge. If there is a T-junction on one edge, we record its index at the corresponding position, otherwise we put “-1” there. For example, in Fig. 3(c), there is a T-junction on the third edge. Assuming its index is TJ 3, we record the T-junctions as “-1 -1 TJ 3 -1”. Following the T-junctions, the next value indicates the total number of duplicated nodes, which is 5 for a corner element and 2 for an edge element. The remaining values specify the relative location of the duplicated nodes with respect to the associated corner of this element. A duplicated node has three consecutive values, the global index, the corner in the T-mesh to which it belongs, and the relative location of this node to the corner.

.TSM to.STSP Conversion. To obtain a logical order of the duplicated nodes, we introduce an STSP plane to help extract the T-spline information from the .TSM patch in Rhino. Fig. 4(a) shows the STSP plane with the center point labeled as 8. This plane is a designed pattern to store the relative location of duplicated nodes with respect to their associated corners. The edge interval length between a duplicated node and its associated corner is zero. This information is further used in extracting knot vectors. For open surface topologically equivalent to a unit square, there are four types of corner elements. Thus, the STSP plane has four subsquares, each of which can be applied to one certain type of corner element or edge element to store the duplicated nodes information. For example, the green square in Fig. 4(a) can be applied to the corner element in Fig. 4(b) while the orange square can be applied to the corner element in Fig. 4(c). In Fig. 4(b), there are three nodes that have duplicated nodes, g 0, g 1, and g 3. Since g 0 has three duplicated nodes g 4, g 5, and g 6, we first put g 0 at the center of the STSP plane which is position 8. In this way, g 4, g 5, and g 6, are located at positions 3, 4, and 5 in the STSP plane, respectively. This indicates g 4 is associated with the corner 0 at the relative location of 3 in the STSP plane. Thus, we record the relative location of this duplicated node as “4 0 3”. Similarly for g 5 and g 6, we record them as “5 0 4” and “6 0 5,” respectively. We can apply the same rule to the remaining g 1 and g 3 with only one duplicated node each. We put g 1 and g 3 at the center of STSP plane and g 7 and g 8 can be recorded as “7 1 5” and “8 3 3,” respectively. Similarly, Fig. 4(c) shows the relative location of all duplicated nodes in another corner element.

Fig. 4
figure 4

(a) The STSP plane; (b) a corner element applied to the green square in (a); and (c) another corner element applied to the orange square in (a). The red edges have zero length.

Full size image

To convert the .TSM data to the .STSP data, we first follow the face link loop to find all the vertices and grips of this element. The four grips at the corners determine the connectivity of this element. They are also the first four values in our data format. With the links, we extract the edge interval associated with the links and record them as parametric length. Then we loop through each grip to order the information of duplicated nodes. We count the total number of duplicated nodes and then record the relative position using the STSP plane. Suppose this element has an edge length of 100 in both parametric directions and has no T-junction, its representation “ 0 1 2 3 100 100 -1 -1 -1 -1 5 4 0 3 5 0 4 6 0 5 7 1 5 8 3 3 ” is shown in Fig. 5.

Fig. 5
figure 5

Sample element data line for the T-mesh element in Fig. 4(a).

Full size image

After .TSM to .STSP data format conversion, we obtain all the information of the T-mesh. If only a 2D geometry is required for analysis, we directly extract the knot vectors and calculate the T-spline surface. If there are extraordinary nodes in the T-mesh. We use the interval duplication method [16] to deal with it. If 3D geometry is needed for analysis, we convert .TSM file to .VTSP file.

.TSM to.VTSP Conversion. We extend the designed pattern from STSP plane to VTSP cube in 3D case. Fig. 6(a) shows the VTSP cube and its labels. In 3D, we put each corner of this element to the center of the cube and for each duplicated node we record its relative location in the cube using the same way as in 2D case. As the example shown in Fig. 6(b), g 6 is associated with corner 1 in the element. After putting corner 1 to the center of the cube which is position 17, g 6 is located at position 23 automatically. Thus we record the duplicated node g 6 as “6 1 23”. Other duplicated nodes can be recorded in the same way. With everything recorded, the information is then used in knot vector extraction and volumetric T-spline construction.

Fig. 6
figure 6

(a) The VTSP cube; and (b) a corner element applied to the green cube in (a). The red edges have zero length.

Full size image

5 Volumetric T-Spline Construction

After data structure conversion, we perform volumetric T-spline construction, using the parametric mapping algorithm [7]. The algorithm first identifies the eight corner nodes on the boundary surface and then maps the surface patch to a unit cube. The interior domain is adaptively subdivided using octree subdivision until each face or edge contains at most one T-junction. Two boundary layers are inserted between the input boundary and subdivision results using the pillowing technique to preserve the input boundary representation. Then, templates are applied around extraordinary nodes to build a valid T-mesh. Finally, the knot vectors are extracted and volumetric T-splines are constructed.

In our approach, instead of inserting two boundary layers, we pillow the 6 patches one by one, resulting in one boundary layer. The reason is that for CAD model with sharp edges, the original method may generate elements with bad quality and introduce unnecessary extraordinary nodes. Our modified method improves the quality and no new extraordinary node is introduced. We use a 16×16 cube to show the difference between these two methods. Fig. 7(a) shows the original input boundary representation. Fig. 7(b) shows the constructed T-splines in Bézier representations using the original algorithm, and Fig. 7(c) shows the results in Bézier representations using the modified algorithm. Note that in the modified method, the one layer inserted is used as the zero-length layer, so they are not extracted for Bézier representations. Finally, the Bézier operators [12] are calculated, which are used for IGA in Abaqus.

Fig. 7
figure 7

Comparison between the original method and the modified method. (a) The boundary representation of the cube; (b) the constructed volumetric T-splines using the original method [7]; and (c) the T-splines using our modified method.

Full size image

6 Abaqus IGA and Visualization

With the surface or constructed volumetric T-spline, the plugin generates an Abaqus.inp file and a.bezier file. The Abaqus.inp file contains T-spline control point coordinates, element connectivities, and the BVP information. The.bezier file is our self-defined file format containing information of T-spline control point weight and Bézier operators. Both files are read into the UELMAT through the User EXTERNAL DataBase (UEXTERNALDB) in Abaqus. The T-spline based UELMAT uses Bézier operator to compute the T-spline basis functions, we then build the stiffness matrix and force vector for the analysis[12].

Abaqus does not support the visualization of user-defined elements. So post-processing is necessary to project the results to a finite element mesh for visualization. In addition to Abaqus, other software like ParaView can also be used for visualization. For linear elastic problems, the displacement can be extracted from the.fil file generated by Abaqus. Then, the nodal values of each element are computed based on the analysis results.

7 Numerical Results and Conclusion

Using the three geometries in Fig. 2, linear elastic problems with a Young’s modulus of 10,000 and a Poisson ratio of 0.3 are solved here, see Fig. 8. The first example shows the displacement and normal strain of a quarter of plate with a hole, which was designed directly in Rhino. The quarter plate is constrained from moving along the horizontal direction at the right edge and vertical direction at the bottom edge. The second example shows the displacement and normal strain of a notch structure under bending, which was created by sweeping the geometry in Fig. 2(b). The generated 2D notch model has one extraordinary node. After dealing with it with the interval duplication method [16], we sweep the geometry to obtain the volumetric T-spline. There is no further requirements for dealing the generated partial extraordinary nodes and we can directly obtain the Bézier extraction matrix. The geometry is fixed at the top and bottom while a load is applied at the tip of the notch structure. The third example shows the deformation and strain of a quarter cylinder, which was created using the conformal parametric mapping method [7]. The cylinder is fixed at one end and the load is applied at the other end.

Fig. 8
figure 8

Analysis results. (a-c) 2D plate with a hole; (d-f) 3D notch structure; and (g-i) 3D quarter cylinder.

Full size image

In conclusion, this chapter presented a novel integrated CAD-CAE T-spline IGA software framework based on Rhino and Abaqus. The framework can solve both surface and volumetric T-spline problems. In particular, this framework realizes the transformation from Rhino surface T-splines to volumetric T-splines based on efficient STSP/VTSP data structures. Three examples were given to demonstrate our software framework. Generalizing this platform to arbitrary topology geometry is possible [6]. We are planning to implement this algorithm, enabling a more general set of geometries in the future.