Software framework and limitations

Before using OpenSG, it is helpful to understand the software framework. OpenSG is a Python package, which contains several subpackages, listed below: Each subpackage contains modules that contain classes, methods, and functions. The classes used to generate blade mesh models and run structural analysis are described in more detail below, followed by a list of software limitations.

See API documentation for more information on the code structure.

OpenSG Subpackages:

core

Contains classes and methods for core computational functions including ABD matrix computation, beam model implementations, and stress recovery.

mesh

Contains classes and methods to define blade mesh models, segment meshes, and mesh data structures for both shell and solid element analyses.

io

Contains classes and methods for input/output operations including YAML file handling, mesh file generation, and data serialization.

utils

Contains utility functions for mathematical operations, finite element computations, eigenvalue solving, and mesh utilities for both shell and solid analyses.

Blade mesh model

The mesh subpackage contains classes to define blade mesh models, segment meshes, and their data structures. These classes are listed below: Blade mesh models can be built from YAML files or generated programmatically. The package supports both shell and solid element analyses for wind turbine blade structural analysis.

Mesh Classes:

ShellSegmentMesh

Class to define individual shell-based blade segments for efficient segment-by-segment analysis without requiring the full blade mesh.

SolidSegmentMesh

Class to define individual solid-based blade segments for 3D structural analysis of blade segments.

Core computational modules

The core subpackage contains classes and functions for the core structural analysis computations. These are listed below:

Core Analysis Classes and Functions:

compute_ABD_matrix()

Function to compute ABD matrices for composite laminates. Relates forces/moments to strains/curvatures in shell structures.

compute_timo_boun()

Function to compute boundary stiffness matrices for Euler-Bernoulli and Timoshenko beam theories on shell boundaries.

compute_stiffness()

Function to compute segment stiffness matrices using shell element formulations.

compute_timo_boun()

Function to compute boundary stiffness matrices for solid element analyses.

compute_stiffness()

Function to compute segment stiffness matrices using solid element formulations.

stress_recov

Module containing functions for stress recovery and post-processing, including local strain computation and stress analysis.

Utility functions

The utils subpackage contains utility functions that support the core analysis capabilities. These are organized by analysis type and listed below:

Utility Modules:

shared

Contains shared utility functions including nullspace computation, linear system solvers, and constraint handling used across both shell and solid analyses.

shell

Contains shell-specific utilities including local frame computations, strain measures, boundary condition handling, and shell element operations.

solid

Contains solid-specific utilities including 3D strain measures, stress computations, boundary markers, and solid element operations.

eigenvalue_solver

Contains eigenvalue solver utilities for advanced analysis including buckling and modal analysis capabilities.

Limitations

Current OpenSG limitations include:

  • Stiffness matrices are currently dense, which can be a memory and performance bottleneck for large or highly refined SGs.

  • No iterative solver option is currently available, which limits scalability for very large problems.

  • Dehomogenization is currently only implemented for solid element SGs via stress_recov. Shell element stress recovery is not yet supported.

  • Current framework focuses primarily on wind turbine blades.

  • OpenSG requires dolfinx version 0.8.0 and is not compatible with newer versions of dolfinx.

Future work

Potential improvements and extensions include:

  • Transitio to sparse matrix representations to improve memory usage and speed for large SGs.

  • Add iterative solver options as an alternative to direct solvers for large-scale problems.

  • Extend dehomogenization to shell element SGs.

  • Add examples that demonstrate piping OpenSG outputs into downstream codes such as OpenFAST.

  • Extend OpenSG framework to other structures.

  • Add support for GPU acceleration using the GPU capabilities of PETSc and FEniCSx as they mature.