Geometry + Simulation Modules (G+Smo)

• Geometry + Simulation Modules (G+Smo) is a framework that couples CAD representations with simulation modules using splines, NURBS, and multipatch strategies.
• It employs advanced spline-based representations—such as B-splines, NURBS, and hierarchical refinements—to support robust analyses in diffusion, elasticity, shells, and structural mechanics.
• Its modular architecture preserves geometric intent and metadata throughout simulation, facilitating interoperability, adaptive error estimation, and integration with various solver algorithms.

to=arxiv_search.search ＿国产 json {"query":"Geometry + Simulation Modules G+Smo isogeometric analysis", "max_results": 10}- {"results":[{"arxiv_id":"(Verhelst et al., 14 Aug 2025)","title":"Isogeometric multi-patch shell analysis using the Geometry + Simulation Modules","authors":"T. Rüberg, M. Ambati, J. J. C. Remmers, R. de Borst, K. Schillinger","summary":"Isogeometric Analysis (IGA) bridges Computer-Aided Design (CAD) and Finite Element Analysis (FEA) by employing splines as a common basis for geometry and analysis. One of the advantages of IGA is in the realm of thin shell analysis: due to the arbitrary continuity of the spline basis, Kirchhoff-Love shells can be modeled without the need to introduce unknowns for the mid-plane rotations, leading to a reduction in the number of unknowns. In this paper, we provide the background of an implementation of Isogeometric Kirchhoff--Love shells within the Geometry + Simulation Modules (G+Smo). This paper accompanies multiple previous publications and elaborates on the design of the software used in these papers, rather than the novelty of the methods presented therein. The presented implementation provides patch coupling via penalty methods and unstructured splines, goal-oriented error estimators, several algorithms for structural analysis and advanced algorithms for the modeling of wrinkling in hyperelastic membranes. These methods are all contained in three new modules in G+Smo: a module for Kirchhoff-Love shells, a module for structural analysis, and a module for unstructured spline constructions. As motivated in this paper, the modules are implemented to be compatible with future developments. For example, by providing base implementations of material laws, by using black-box functions for the structural analysis module, or by providing a standardized approach for the implementation of unstructured spline constructions. Overall, this paper demonstrates that the new modules contribute to a versatile ecosystem for the modeling of multi-patch shell problems through fast off-the-shelf solvers with a simple interface, designed to be extended in future research.","published":"2025-08-14","categories":["cs.MS","math.NA"]},{"arxiv_id":"(Langer et al., 2014)","title":"Multipatch Discontinuous Galerkin Isogeometric Analysis","authors":"A. Langer, U. Langer, J. Moore, M. Neumüller","summary":"Isogeometric analysis (IgA) uses the same class of basis functions for both, representing the geometry of the computational domain and approximating the solution. In practical applications, geometrical patches are used in order to get flexibility in the geometrical representation. This multi-patch representation corresponds to a decomposition of the computational domain into non-overlapping subdomains also called patches in the geometrical framework. We will present discontinuous Galerkin (dG) methods that allow for discontinuities across the subdomain (patch) boundaries. The required interface conditions are weakly imposed by the dG terms associated with the boundary of the sub-domains. The construction and the corresponding discretization error analysis of such dG multi-patch IgA schemes will be given for heterogeneous diffusion model problems in volumetric 2d and 3d domains as well as on open and closed surfaces. The theoretical results are confirmed by numerous numerical experiments which have been performed in G+SMO. The concept and the main features of the IgA library G+SMO are also described.","published":"2014-11-10","categories":["math.NA"]},{"arxiv_id":"(Shamanskiy et al., 2018)","title":"Isogeometric Simulation of Thermal Expansion for Twin Screw Compressors","authors":"M. R. Bercovier, A. Korotov, M. R. Raza, K. J. R. M. Rozza?","summary":"Isogeometric Analysis (IGA) is a recently introduced computational approach intended to breach the gap between the Finite Element Analysis and the Computer Aided Design worlds. In this work, we apply it to numerically simulate thermal expansion of oil-free twin screw compressors in operation. High global smoothness of IGA leads to a more accurate representation of the compressor geometry. We utilize standard tri-variate B-splines to parametrize the rotors, while the casing is modeled exactly by using NURBS. We employ the Galerkin version of IGA to solve the thermal expansion problem in the stationary case. The results allow to estimate the contraction of the clearance space between the casing and the rotors. The implementation is based on the open source C++ library G+Smo. This work is supported by the European Union within the Project MOTOR: Multi-ObjecTive design Optimization of fluid eneRgy machines.","published":"2018-05-22","categories":["cs.CE","math.NA"]},{"arxiv_id":"(Oppizzi et al., 2017)","title":"The Geometry + Simulation Modules: Implementing Isogeometric Analysis","authors":"A. Mantzaflaris, B. Jüttler, B. V. Wohlmuth, M. Takacs","summary":"Isogeometric Analysis (IGA) is a methodology based on the concept of using spline functions to describe computational domains and approximate the unknown fields of a problem; it enables the seamless integration of design and analysis through the use of common representation methods. The Geometry + Simulation Modules (G+Smo) is an object-oriented C++ library for implementing IGA. The library's design and structure are built around C++'s generic programming paradigm to accommodate a broad range of applications. The concepts of object-oriented analysis and design are employed in conjunction with advanced C++ template techniques to accomplish adaptability and efficiency, as addressed in the definition of the XML data format used. This article introduces the basic concepts of the library and its structure, aiming to provide enough details and examples to help interested readers accelerate their use or extension of the library. The article concludes with several practical examples that illustrate how to use the library to study real-world applications.","published":"2017-11-22","categories":["cs.MS","math.NA"]},{"arxiv_id":"(Heltai et al., 2019)","title":"Propagating geometry information to finite element computations","authors":"W. Bangerth, T. Heister, R. Kronbichler, M. Maier, K. Simon, D. Wells","summary":"The traditional workflow in continuum mechanics simulations is that a geometry description -- for example obtained using Constructive Solid Geometry or Computer Aided Design tools -- forms the input for a mesh generator. The mesh is then used as the sole input for the finite element, finite volume, and finite difference solver, which at this point no longer has access to the original, \"underlying\" geometry. However, many modern techniques -- for example, adaptive mesh refinement and the use of higher order geometry approximation methods -- really do need information about the underlying geometry to realize their full potential. We have undertaken an exhaustive study of where typical finite element codes use geometry information, with the goal of determining what information geometry tools would have to provide. Our study shows that nearly all geometry-related needs inside the simulators can be satisfied by just two \"primitives\": elementary queries posed by the simulation software to the geometry description. We then show that it is possible to provide these primitives in all of the frequently used ways in which geometries are described in common industrial workflows, and illustrate our solutions using a number of examples.","published":"2019-10-22","categories":["cs.MS","math.NA"]},{"arxiv_id":"(Adil et al., 2023)","title":"A G+Smo extension for stable vector spline spaces","authors":"K. Schillinger, M. Ambati, T. Takacs, T. Rüberg, J. Evans, R. de Borst","summary":"We present an extension of the Geometry + Simulation Modules (G+Smo) for the construction of stable vector spline spaces and the solution of div- and curl-conforming problem formulations. The paper accompanies the open-source implementation of two methods developed for constructing divergence- and curl-conforming multi-patch B-spline spaces, namely, the sub-structuring approach and the Piola method. The former yields a multipatch div-conforming discretization by splitting off vertex and edge functions. The latter generates both div- and curl-conforming B-splines using Piola transformations. These constructions are complemented by suitable local interpolation operators. For improved usability, these methods are embedded in an extensible software architecture and supplemented with some examples. We also show how the new classes can be employed to solve boundary value problems for linear elasticity and Stokes flow.","published":"2023-05-25","categories":["cs.MS","math.NA"]},{"arxiv_id":"(Hingant et al., 2018)","title":"Hierarchical analysis-suitable T-splines: Formulation, Bézier extraction, and application as an adaptive basis for trimmed isogeometric analysis","authors":"D. Proserpio, A. L. G. Martins, C. Giannelli, T. J. R. Hughes, A. Reali","summary":"Locally refinable T-splines may significantly enhance the efficiency and flexibility of isogeometric analysis by reducing the number of degrees of freedom and simplifying the treatment of complex geometry. In this work, a novel spline technology, termed hierarchical analysis-suitable T-splines (HASTS), is presented. The proposed basis function set allows local refinement and coarsening by construction, is linearly independent, possesses a convex partition of unity, and satisfies an extension of the analysis-suitability constraint. We also introduce in depth the Bézier extraction for HASTS, a direct link from spline spaces to finite element data structures and element technology, and discuss efficient implementation details. We show that HASTS are an effective, accurate, and robust basis for isogeometric analysis. We assess the accuracy and optimal convergence rates of HASTS for an assortment of engineering and design benchmark problems in both two and three dimensions.","published":"2018-07-31","categories":["math.NA","cs.CE"]},{"arxiv_id":"(Maleki et al., 2021)","title":"Geometry encoding for numerical simulations","authors":"K. Shankar, N. V. Chawla, A. H. Baker","summary":"We present a notion of geometry encoding suitable for machine learning-based numerical simulation. In particular, we delineate how this notion of encoding is different than other encoding algorithms commonly used in other disciplines such as computer vision and computer graphics. We also present a model comprised of multiple neural networks including a processor, a compressor and an evaluator.These parts each satisfy a particular requirement of our encoding. We compare our encoding model with the analogous models in the literature","published":"2021-04-15","categories":["cs.LG","cs.CE","stat.ML"]},{"arxiv_id":"(Modi et al., 2024)","title":"Simplicits: Mesh-Free, Geometry-Agnostic, Elastic Simulation","authors":"A. Li, G. T. Henne, T. Van Wouwe, M. Fisher, A. Jacobson, J. T. K. Hu","summary":"The proliferation of 3D representations, from explicit meshes to implicit neural fields and more, motivates the need for simulators agnostic to representation. We present a data-, mesh-, and grid-free solution for elastic simulation for any object in any geometric representation undergoing large, nonlinear deformations. We note that every standard geometric representation can be reduced to an occupancy function queried at any point in space, and we define a simulator atop this common interface. For each object, we fit a small implicit neural network encoding spatially varying weights that act as a reduced deformation basis. These weights are trained to learn physically significant motions in the object via random perturbations. Our loss ensures we find a weight-space basis that best minimizes deformation energy by stochastically evaluating elastic energies through Monte Carlo sampling of the deformation volume. At runtime, we simulate in the reduced basis and sample the deformations back to the original domain. Our experiments demonstrate the versatility, accuracy, and speed of this approach on data including signed distance functions, point clouds, neural primitives, tomography scans, radiance fields, Gaussian splats, surface meshes, and volume meshes, as well as showing a variety of material energies, contact models, and time integration schemes.","published":"2024-06-09","categories":["cs.GR","cs.LG"]},{"arxiv_id":"(Montag et al., 2018)","title":"Bringing Together Dynamic Geometry Software and the Graphics Processing Unit","authors":"U. Kortenkamp, J. Richter-Gebert, M. von Gagern, C. J. C. Reus, T. Schmitt, C. M. Schröder","summary":"We equip dynamic geometry software (DGS) with a user-friendly method that enables massively parallel calculations on the graphics processing unit (GPU). This interplay of DGS and GPU opens up various applications in education and mathematical research. The GPU-aided discovery of mathematical properties, interactive visualizations of algebraic surfaces (raycasting), the mathematical deformation of images and footage in real-time, and computationally demanding numerical simulations of PDEs are examples from the long and versatile list of new domains that our approach makes accessible within a DGS. We ease the development of complex (mathematical) visualizations and provide a rapid-prototyping scheme for general-purpose computations (GPGPU). The possibility to program both CPU and GPU with the use of only one high-level (scripting) programming language is a crucial aspect of our concept. We embed shader programming seamlessly within a high-level (scripting) programming environment. The aforementioned requires the symbolic process of the transcompilation of a high-level programming language into shader programming language for GPU and, in this article, we address the challenge of the automatic translation of a high-level programming language to a shader language of the GPU. To maintain platform independence and the possibility to use our technology on modern devices, we focus on a realization through WebGL.","published":"2018-08-14","categories":["cs.GR","cs.CG"]}]} Geometry + Simulation Modules (G+Smo, also written G+SMO in earlier work) denotes an object-oriented C++ framework for isogeometric analysis and, more broadly, a geometry-aware simulation architecture in which CAD-style representations, spline bases, multipatch topologies, assembly operators, and solver modules remain coupled instead of being separated by a mesh-only handoff. In the library literature, this coupling is realized through B-splines, NURBS, hierarchical spline technologies, multipatch containers, and analysis modules for diffusion, elasticity, shells, and structural computations [(Langer et al., 2014); (Verhelst et al., 14 Aug 2025)]. In a broader reading, work on geometry propagation, CAD-to-simulation transfer, simulation-oriented geometry encoding, and representation-agnostic elastic simulation addresses the same underlying problem: how to preserve geometric intent, metric information, and assembly structure as geometry moves into numerical analysis (Heltai et al., 2019, Vuosalo et al., 2017).

1. Foundational concept and software architecture

G+SMO was presented as an object-oriented, template-based C++ library for isogeometric analysis, motivated by the mismatch between conventional finite element software organized around element meshes and nodal basis functions, and CAD workflows organized around parametric patches, control points, spline/NURBS bases, and exact geometric mappings (Langer et al., 2014). Its core abstraction is that geometry, basis, fields, assembly, and solution processes should all be represented in a form natural to isogeometric analysis rather than retrofitted from standard FEM infrastructure.

The early architecture centers on an abstract basis class, an abstract geometry class, and a function abstraction, with the geometry class itself deriving from the function abstraction. Derived geometry classes include curve, surface, volume, and bulk, corresponding to parameter dimensions $1,2,3,4$. A multipatch object stores both the list of patches and the topological connectivity information between them, including adjacency, boundary incidence, and degenerate points. A field class represents scalar or vector-valued PDE solutions defined over a patch or multipatch object and evaluable in either parameter or physical space (Langer et al., 2014).

A later implementation-oriented shell paper makes the class hierarchy more explicit. Any spline basis inherits from gsBasis; examples include tensor-product B-splines (gsTensorBSplineBasis), NURBS (gsTensorNurbsBasis), and hierarchical or truncated hierarchical B-splines (gsHBSplineBasis, gsTHBSplineBasis). Multiple bases can be grouped in a gsMultiBasis for multi-patch analysis. Their geometric counterparts inherit from gsGeometry, and multi-patch geometries are stored in gsMultiPatch (Verhelst et al., 14 Aug 2025). This yields a common language for geometry and analysis across CAD-imported NURBS surfaces, fitted spline geometries, hierarchically refined surfaces, and mapped or unstructured spline spaces.

Module family	Main role	Source
Core, Matrix, NURBS, Modeling, Input/Output, Assembler	Abstract interfaces, linear algebra, spline technology, CAD preparation, visualization and exchange, PDE assembly	(Langer et al., 2014)
gsKLShell	Kirchhoff–Love shell assembly	(Verhelst et al., 14 Aug 2025)
gsStructuralAnalysis	Nonlinear statics, modal analysis, buckling, continuation, dynamic relaxation	(Verhelst et al., 14 Aug 2025)
gsUnstructuredSplines	Strong multi-patch smooth spline constructions	(Verhelst et al., 14 Aug 2025)

The Matrix module is based on Eigen and provides dense and sparse matrices and vectors, direct decompositions, iterative solvers, and interfaces to PARADISO and SuperLU. The NURBS module provides B-splines, NURBS, Bézier objects, tensor-product constructions, and arbitrary degree and knot-vector support. The Modeling module handles trimmed surfaces, B-rep solids, triangle meshes, spline fitting, smoothing point clouds, Coons patches, and volume segmentation. The Assembler module supports convection-diffusion, linear elasticity, Stokes, and surface diffusion using both continuous and discontinuous Galerkin methods, with both strong and weak imposition of Dirichlet conditions and Neumann-type conditions (Langer et al., 2014).

A recurrent design principle in the later shell implementation is future compatibility. The new modules are organized so that constitutive laws are decoupled from kinematics and assembly, structural solvers consume black-box residual and Jacobian operators, and unstructured spline constructions follow a standardized implementation pattern (Verhelst et al., 14 Aug 2025). That emphasis on modularity is central to the meaning of “Geometry + Simulation Modules.”

2. Geometric representations and multipatch modeling

Multipatch geometry is the canonical representation throughout G+Smo. In the multipatch dG-IgA formulation, the computational domain is decomposed into non-overlapping subdomains,

$$\overline{\Omega}=\bigcup_{i=1}^N \overline{\Omega_i},\qquad \Omega_i\cap \Omega_j=\emptyset \ \text{for } i\neq j,$$

and each patch $\Omega_i$ is represented by a spline or NURBS map from the parameter domain $\widehat\Omega=(0,1)^d$,

$$\Phi_i:\widehat\Omega\to\Omega_i,\qquad \Phi_i(\hat x)=\sum_j C_j^{(i)} \hat B_j^{(i)}(\hat x).$$

The corresponding physical spline space is obtained by pullback through $\Psi_i=\Phi_i^{-1}$ (Langer et al., 2014). This is the standard G+Smo geometry-analysis coupling: the same parametric machinery that defines the patch geometry also defines the discrete space.

The compressor case study illustrates how this logic extends to difficult industrial geometry. In the twin screw compressor application, the original rotor data are point clouds with 2572 points for the male rotor and 2292 points for the female rotor. These are scaled to a reference compressor configuration with axis distance 80 mm, rotor radius 50.97 mm, clearance between casing and rotors 44 $\mu$m, and clearance between rotors approximately 100 $\mu$m (Shamanskiy et al., 2018). The rotor profiles are approximated by cubic B-spline curves, with deviation from the point cloud kept below 10% of the clearance height, using 73 control points for the male profile and 109 control points for the female profile. The male rotor’s four sharp corners are represented by increasing knot multiplicities.

The 2D cross-sections of these rotors are parameterized using a scaled boundary approach. Each cross-section consists of an outer layer obtained by scaling inward from the boundary toward a central circular patch representing the shaft region. The resulting parameterization is $C^2$ inside each patch and only $C^0$ across patch interfaces; the mapping for the central patch is not bijective at the center, but is stated to be analysis-suitable (Shamanskiy et al., 2018). In 3D, each rotor is built as a multi-patch geometry with 4 patches, using 20 layers of control points; rotor lengths are 168.3 mm, with helical pitches of $$\overline{\Omega}=\bigcup_{i=1}^N \overline{\Omega_i},\qquad \Omega_i\cap \Omega_j=\emptyset \ \text{for } i\neq j,$$0 for the male rotor and $$\overline{\Omega}=\bigcup_{i=1}^N \overline{\Omega_i},\qquad \Omega_i\cap \Omega_j=\emptyset \ \text{for } i\neq j,$$1 for the female rotor. By contrast, the casing is modeled exactly by NURBS, specifically because circular arcs can be represented exactly (Shamanskiy et al., 2018).

The shell module extends geometric representation beyond tensor-product patching through mapped smooth spaces. In gsUnstructuredSplines, local patchwise basis functions $$\overline{\Omega}=\bigcup_{i=1}^N \overline{\Omega_i},\qquad \Omega_i\cap \Omega_j=\emptyset \ \text{for } i\neq j,$$2 are mapped to global smooth basis functions $$\overline{\Omega}=\bigcup_{i=1}^N \overline{\Omega_i},\qquad \Omega_i\cap \Omega_j=\emptyset \ \text{for } i\neq j,$$3 through a sparse coefficient matrix $$\overline{\Omega}=\bigcup_{i=1}^N \overline{\Omega_i},\qquad \Omega_i\cap \Omega_j=\emptyset \ \text{for } i\neq j,$$4,

$$\overline{\Omega}=\bigcup_{i=1}^N \overline{\Omega_i},\qquad \Omega_i\cap \Omega_j=\emptyset \ \text{for } i\neq j,$$5

This is implemented through gsMappedBasis and gsMappedSpline, enabling globally smooth analysis spaces over patch networks with extraordinary vertices (Verhelst et al., 14 Aug 2025). The practical significance is that multi-patch shell analysis need not be restricted to weakly coupled $$\overline{\Omega}=\bigcup_{i=1}^N \overline{\Omega_i},\qquad \Omega_i\cap \Omega_j=\emptyset \ \text{for } i\neq j,$$6 interfaces; strong $$\overline{\Omega}=\bigcup_{i=1}^N \overline{\Omega_i},\qquad \Omega_i\cap \Omega_j=\emptyset \ \text{for } i\neq j,$$7-type constructions become analysis-ready objects inside the same framework.

3. Discretization, coupling, and structural algorithms

The earliest major G+SMO numerical formulation in the supplied literature is multipatch discontinuous Galerkin isogeometric analysis for diffusion on volumetric domains and on open and closed surfaces (Langer et al., 2014). The global broken approximation space is

$$\overline{\Omega}=\bigcup_{i=1}^N \overline{\Omega_i},\qquad \Omega_i\cap \Omega_j=\emptyset \ \text{for } i\neq j,$$8

with no continuity enforced across interfaces. For an interior face $$\overline{\Omega}=\bigcup_{i=1}^N \overline{\Omega_i},\qquad \Omega_i\cap \Omega_j=\emptyset \ \text{for } i\neq j,$$9, averages and jumps are defined by

$\Omega_i$0

The symmetric interior penalty structure weakly imposes interface conditions through consistency, symmetry, and penalty terms, with penalty scaling

$\Omega_i$1

on interior interfaces and

$\Omega_i$2

on boundary faces (Langer et al., 2014). The broken norm is

$\Omega_i$3

and the main volumetric a priori estimate is formulated in terms of

$\Omega_i$4

The paper emphasizes optimal convergence rates in the broken dG norm under low-regularity assumptions (Langer et al., 2014).

The 2025 shell implementation generalizes G+Smo from scalar diffusion and related PDEs to a full structural-analysis stack for thin shells (Verhelst et al., 14 Aug 2025). The implemented Kirchhoff–Love formulation is pure displacement-based, exploiting the arbitrary continuity of spline bases so that shell analysis proceeds without introducing unknowns for the mid-plane rotations. After spline discretization, the residual entry is

$\Omega_i$5

and the consistent tangent matrix is

$\Omega_i$6

For linear analysis,

$\Omega_i$7

and for dynamics, neglecting rotational inertia, the mass matrix is

$\Omega_i$8

These are assembled by gsThinShellAssembler (Verhelst et al., 14 Aug 2025).

Constitutive behavior is deliberately modular. gsThinShellAssembler delegates constitutive evaluation to classes rooted at gsMaterialMatrixBase, with derived classes including gsMaterialMatrixLinear, gsMaterialMatrixComposite, gsMaterialMatrixNonlinear, and gsMaterialMatrixTFT for tension field theory. Because these material laws act as black boxes, the same shell assembler can be combined with Saint-Venant–Kirchhoff linear elasticity, laminated composites, Neo-Hookean, Mooney–Rivlin, Ogden, and wrinkling-aware membrane modifications (Verhelst et al., 14 Aug 2025).

Patch coupling is supported in two distinct ways. Weak coupling adds penalty terms for both $\Omega_i$9 displacement mismatch and $\widehat\Omega=(0,1)^d$0 rotational or slope mismatch across interfaces. Strong coupling instead uses globally smooth mapped bases, so the shell variational form needs no extra interface terms (Verhelst et al., 14 Aug 2025). This distinction is characteristic of G+Smo: interface continuity is treated as a configurable analysis module, not as a fixed property of the geometry.

At the solver level, gsStructuralAnalysis consumes discrete operators through standardized callable interfaces such as ALResidual_t and Jacobian_t. Main classes include gsStaticBase, gsStaticDR, gsStaticNewton, gsStaticComposite, gsEigenProblemBase, gsModalSolver, gsBucklingSolver, gsALMBase, gsALMLoadControl, gsALMRiks, and gsALMCrisfield (Verhelst et al., 14 Aug 2025). Implemented algorithms include Newton’s method,

$\widehat\Omega=(0,1)^d$1

dynamic relaxation based on

$\widehat\Omega=(0,1)^d$2

modal analysis through

$\widehat\Omega=(0,1)^d$3

linear buckling, arc-length continuation, and the Adaptive Parallel Arc-Length Method (Verhelst et al., 14 Aug 2025). Goal-oriented error estimation is provided through a dual-weighted residual implementation in gsThinShellAssemblerDWR.

4. Geometry-to-simulation interoperability

A major theme associated with G+Smo is that geometry should remain available to the simulator after meshing or after model export. The paper on propagating geometry information to finite element computations reduces most geometry-related needs inside large finite element codes to two abstract queries, termed primitives (Heltai et al., 2019).

The first primitive is “New point”: given $\widehat\Omega=(0,1)^d$4 existing points $\widehat\Omega=(0,1)^d$5 and weights $\widehat\Omega=(0,1)^d$6 with $\widehat\Omega=(0,1)^d$7, return a new interpolated point

$\widehat\Omega=(0,1)^d$8

The second is “Tangent vector”: $\widehat\Omega=(0,1)^d$9 From these two queries, the authors construct mesh-refinement points, high-order mapping support points, Jacobians, tangent bases, normals,

$$\Phi_i:\widehat\Omega\to\Omega_i,\qquad \Phi_i(\hat x)=\sum_j C_j^{(i)} \hat B_j^{(i)}(\hat x).$$0

and transfinite interior extensions. They also note an important limitation: second and higher derivatives of exact nonpolynomial geometry maps cannot be obtained exactly from the two primitives alone (Heltai et al., 2019). In architectural terms, this is a minimal solver-facing interface for geometry-aware simulation.

A practical interoperability instance of the same problem appears in SW2GDML, a direct CAD-to-simulation bridge from SOLIDWORKS engineering models into Geant4 via GDML (Vuosalo et al., 2017). The tool is implemented as about 3000 lines of C++ in Microsoft Visual Studio and is organized into three modules: one reads parts and surfaces from the SOLIDWORKS API, one associates surfaces into solids and computes coordinate transformations, and one writes GDML. The direct API route is important because the common STEP-to-GDML path is described as dropping material properties and producing very large and unwieldy tessellated solids that can reduce Geant4 performance (Vuosalo et al., 2017).

SW2GDML instead emits compact, human-readable GDML using standard solids and boolean operations. The supported feature set is explicit: board, cone, cylinder (full and partial), disk (full and partial), half-ellipsoid with a circular face, torus, cylindrical holes in parts, multiple coordinate systems in simple configurations, and repeated parts in linear patterns. The appendix examples show primitive mappings such as <cone>, <torus>, <ellipsoid>, and <tube>, boolean <subtraction>, and hierarchical <volume>, <physvol>, <position>, and <rotation> placement records. Material extraction is preserved, for example through a GDML material entry for AISI_316_Stainless_Steel_Sheet_.SS. with density and elemental fractions (Vuosalo et al., 2017).

From a broader G+Smo perspective, these works support the same principle: simulation modules benefit when the transfer layer preserves higher-level geometric primitives, material metadata, and hierarchical placement rather than flattening everything into generic tessellations or geometry-free meshes. The papers differ in domain—finite elements versus Geant4 transport—but the modular lesson is closely aligned.

5. Applications, benchmarks, and empirical scope

G+SMO’s early validation was heavily tied to multipatch diffusion problems in 2D, 3D, and on surfaces (Langer et al., 2014). All numerical experiments in the dG-IgA paper were performed in G+SMO. The test set includes smooth and low-regularity volumetric diffusion on $$\Phi_i:\widehat\Omega\to\Omega_i,\qquad \Phi_i(\hat x)=\sum_j C_j^{(i)} \hat B_j^{(i)}(\hat x).$$1, nonmatching two-patch meshes with refinement ratio $$\Phi_i:\widehat\Omega\to\Omega_i,\qquad \Phi_i(\hat x)=\sum_j C_j^{(i)} \hat B_j^{(i)}(\hat x).$$2 up to 40, graded meshes for singularities on an L-shaped domain and for an interior point singularity, a six-patch sphere, a four-patch torus, a torus with heterogeneous diffusion coefficients $$\Phi_i:\widehat\Omega\to\Omega_i,\qquad \Phi_i(\hat x)=\sum_j C_j^{(i)} \hat B_j^{(i)}(\hat x).$$3 and $$\Phi_i:\widehat\Omega\to\Omega_i,\qquad \Phi_i(\hat x)=\sum_j C_j^{(i)} \hat B_j^{(i)}(\hat x).$$4, and an open CAD car shell composed of eight quadratic B-spline patches (Langer et al., 2014). On smooth cases, observed rates approach the optimal $$\Phi_i:\widehat\Omega\to\Omega_i,\qquad \Phi_i(\hat x)=\sum_j C_j^{(i)} \hat B_j^{(i)}(\hat x).$$5-th order behavior in the dG norm and $$\Phi_i:\widehat\Omega\to\Omega_i,\qquad \Phi_i(\hat x)=\sum_j C_j^{(i)} \hat B_j^{(i)}(\hat x).$$6 in $$\Phi_i:\widehat\Omega\to\Omega_i,\qquad \Phi_i(\hat x)=\sum_j C_j^{(i)} \hat B_j^{(i)}(\hat x).$$7 where expected; on low-regularity cases, rates are reduced exactly as predicted by theory. On sphere and torus examples, dG-IgA and continuous Galerkin IgA have nearly identical $$\Phi_i:\widehat\Omega\to\Omega_i,\qquad \Phi_i(\hat x)=\sum_j C_j^{(i)} \hat B_j^{(i)}(\hat x).$$8 errors (Langer et al., 2014).

The twin screw compressor study provides a compact but concrete industrial thermo-mechanical application (Shamanskiy et al., 2018). The stationary linear thermoelastic simulation predicts male rotor axial elongation of 317 $$\Phi_i:\widehat\Omega\to\Omega_i,\qquad \Phi_i(\hat x)=\sum_j C_j^{(i)} \hat B_j^{(i)}(\hat x).$$9m, or 370 $\Psi_i=\Phi_i^{-1}$0m including the shaft; female rotor axial elongation of 251 $\Psi_i=\Phi_i^{-1}$1m, or 300 $\Psi_i=\Phi_i^{-1}$2m including the shaft; male rotor radial expansion of 92 $\Psi_i=\Phi_i^{-1}$3m; female rotor radial expansion of 79 $\Psi_i=\Phi_i^{-1}$4m; and casing inward expansion toward rotors of 12 $\Psi_i=\Phi_i^{-1}$5m. The radial expansion is reported to be in very good agreement with a previous study, but the results also imply that the initial 44 $\Psi_i=\Phi_i^{-1}$6m rotor-casing clearance is completely closed, while near the sharp edge of the male rotor the rotor-rotor clearance contracts by approximately 60% (Shamanskiy et al., 2018). The paper is explicit that further investigation is needed to understand this excessive radial expansion.

The shell ecosystem paper validates a broader class of structural problems (Verhelst et al., 14 Aug 2025). Its benchmark set includes a uniaxial tension membrane for nonlinear hyperelastic constitutive checks, a twisted-and-stretched cylinder for tension-field-theory wrinkling, a T-beam for weak penalty coupling, a car side panel for strong multi-patch coupling through unstructured spline spaces and modal analysis, a wrinkling sheet under tension for arc-length continuation and branch switching, a snapping metamaterial for limit-point instability and APALM continuation, and an adaptive wrinkling simulation for dual-weighted-residual-driven hierarchical refinement. The paper characterizes its contribution as an implementation and ecosystem paper rather than a theory-first paper, but the examples show that difficult shell phenomena—multi-patch continuity, hyperelasticity, wrinkling, bifurcation, and goal-oriented adaptivity—are all available within the same open-source framework (Verhelst et al., 14 Aug 2025).

The SW2GDML paper validates its interoperability layer mainly through successful Geant4 import and visual agreement between CAD and Geant4 renderings for simple LUX-ZEPLIN models, including a simple model of the LZ outer and inner tanks, a simple model of the LZ inner tank, and a simple model of one LZ liquid scintillator tank (Vuosalo et al., 2017). The paper does not report numerical benchmarks for file size, memory, or navigation speed, and that absence is material to interpreting its scope.

6. Broader research directions, reinterpretations, and limitations

A broader G+Smo reading extends beyond classical spline-based isogeometric analysis to any module stack that keeps geometry semantically alive for simulation. The paper on geometry encoding for numerical simulations is an early neural proposal in this direction (Maleki et al., 2021). It defines simulation-oriented geometry encoding through four requirements: global accuracy of encoding, compressed encoding, continuity and differentiability of encoding, and variable encoding/decoding resolution. The proposed model consists of a processor, compressor, and evaluator. The processor is a U-net that maps a binary 2D geometry image to a signed distance field; the compressor is a convolutional autoencoder without skip connections; the evaluator is bilinear interpolation in PyTorch, designed to support automatic differentiation (Maleki et al., 2021). On the reported MNIST comparison over 500 validation examples, the processor and compressor outperform MetaSDF, while the compressor achieves $\Psi_i=\Phi_i^{-1}$7 compression with insignificant loss of accuracy. This is not a full PDE solver, but it is a geometry module designed explicitly for numerical simulation.

The supplied supplementary material for “Simplicits” shows a different, representation-agnostic trajectory (Modi et al., 2024). Its experiments cover Splats, CT, SDF, Mesh, Nerf, and Points, with per-example settings including cubature points, handles, training steps, Newton Iters, and Log Barrier Its. Because the supplied content is only the supplementary table and not the full method description, exact losses, constitutive laws, and runtime equations are not available here. This suggests, rather than proves, a G+Smo-adjacent strategy in which the common interface is not a spline basis but a queryable occupancy-style geometric oracle (Modi et al., 2024).

The GPU integration paper adds an execution-architecture perspective (Montag et al., 2018). It embeds shader programming inside a high-level scripting environment, parses the source into an abstract syntax tree, splits GPU-suitable and CPU-only subexpressions, transcompiles dynamically typed code to GLSL using fixed-point type inference, and executes on WebGL. The framework exposes commands such as colorplot and map, and supports GPU-aided mathematical discovery, raycasting of algebraic surfaces, real-time deformation of images and footage, and computationally demanding numerical simulations of PDEs (Montag et al., 2018). This is not a CAD/NURBS G+Smo system, but it is highly relevant to the execution layer of geometry-aware computation.

At the nonlinear solver layer, Anderson acceleration provides a reusable acceleration mechanism for local-global fixed-point solvers in geometry optimization and projective dynamics (Peng et al., 2018). The paper rewrites a local-global iteration as

$\Psi_i=\Phi_i^{-1}$8

applies Anderson acceleration with canonical mixing parameter $\Psi_i=\Phi_i^{-1}$9, and safeguards stability by accepting the accelerated iterate only if it decreases the target energy relative to the previous iterate. The method significantly reduces iteration count with only a slight increase of computational cost per iteration (Peng et al., 2018). For G+Smo-style software, this is naturally interpreted as a solver decorator rather than a geometry representation.

Several limitations recur across the cited work. The dG multipatch and compressor papers show strong capability but are not step-by-step implementation manuals [(Langer et al., 2014); (Shamanskiy et al., 2018)]. The shell paper explicitly states that its main contribution is software design and coherent implementation rather than new shell theory (Verhelst et al., 14 Aug 2025). SW2GDML can convert simple SOLIDWORKS models but cannot yet handle complex SOLIDWORKS models; unsupported features may be omitted entirely or may cause part misplacement (Vuosalo et al., 2017). The two-primitives geometry-oracle program does not provide exact second and higher geometric derivatives (Heltai et al., 2019). The geometry-encoding paper is restricted to binary 2D images and does not demonstrate an end-to-end PDE solve (Maleki et al., 2021). In the Simplicits material, the absence of the main text limits what can be stated rigorously (Modi et al., 2024).

A common misconception is to treat G+Smo as only a spline data structure library. The supplied literature shows a wider stack: abstract geometry and basis classes, multipatch topology, Galerkin and dG assembly, shell and structural solvers, constitutive-law interfaces, CAD preparation, geometry propagation, and interoperability mechanisms [(Langer et al., 2014); (Verhelst et al., 14 Aug 2025)]. A second misconception is that geometry-aware simulation is identical to exact CAD-basis analysis. The two-primitives framework, SW2GDML, SDF-based geometry encoding, and representation-agnostic elastic simulation suggest a broader family of solutions in which geometry may be preserved through queries, signed distance fields, or semantics-aware conversion rather than only through identical geometry and analysis bases (Heltai et al., 2019, Vuosalo et al., 2017, Maleki et al., 2021). That broader interpretation is an inference from the supplied materials, but it is consistent with their shared architectural concern: numerical simulation performs better when geometry is not discarded.