Open VOGEL

OpenVOGEL
	OpenVOGEL Tucan and logo (Common blackbird)
Original author(s)	Guillermo Hazebrouck
Developer(s)	The OpenVOGEL community
Initial release	1 March 2016
Preview release	Tucan 1.2 / 3 September 2019
Written in	VB.NET, C#.NET
Engine
Operating system	Windows, Linux
Available in	English
Type	Computational fluid dynamics, Simulation software, Aeroelasticity
License	GNU GPLv3
Website	openvogel.org

Search Open VOGEL on Amazon.

OpenVOGEL^[1] is a collection of free open source computer packages intended for the simulation of aerodynamic problems through the Unsteady Vortex Lattice Method and first order singularity panels (vortex rings, flat doublet panels and flat source/sink panels). The project provides a main application (named Tucan) that integrates all the packages in an interactive and intuitive way for final users. However, any other library can be linked to an external project without the need of a graphical toolkit. A console application has also been developed to provide the same calculation capability as Tucan but without graphical interface. This program extends the service to Linux users, since it is able to run under the Mono runtime without recompilation. All libraries and applications are fully developed in the .NET framework using Visual Studio Express and they are published under General Public License, GPLv3.

The OpenVOGEL project comprises the next set of libraries (originally developed by Guillermo Hazebrouck):

DesignTools (VB): contains the visual models (which includes slender surfaces, fuselages and other components).
AeroTools (VB): contains the calculation core with generalized definitions based in potential flow and finite elements.
MathTools (VB): contains general math algorithms used for solving the potential and structural problems.
GpuTools (C#): a calculation bridge to the GPU using Cudafy.NET (this module is under development).
Tucan: a set of winforms-based GUI tools integrating all libraries.
Console: a console application that only integrates the modelling and calculation libraries to launch the calculations without interactive GUI in the most common operating systems.

Additionally, the project relies in the next third party libraries:

DotNumerics: a branch of the DotNumerics project (translation of LAPACK and BLAS to .NET) developed by Jose Antonio De Santiago-Castillo, where the sub space iteration algorithm for the generalized eigen-modes problem has been added.
SharpGL: a C# binding for OpenGL written by Dave Kerr.
Cudafy: a set of C# libraries for GPU calls developed by Hybrid DSP (this package is currently only used for evaluation).

A feature of the Open VOGEL project is that users can add their own models to the library, and expand that way the general capabilities of the software or adapt it for a specific purpose. In that sense, the software acts as a basic framework for research applications. Any university, research group or individual in the world is authorized to take the source code, modify it and release it under GPLv3 for further use in the aeronautical community.

The idea behind this experimental way of working is that those who use the software for practical applications can directly benefit from what researchers are achieving, so that their results can be directly put into practice.

Modelling[edit]

One of the key features of Open VOGEL is that it provides built-in tools intended to facilitate the creation of geometrical models. Each component is defined in a parametric way, and the software resolves the geometry to generate a suitable mesh optimized for the calculation core.

Open VOGEL currently allows three types of models: slender lifting surfaces, closed fuselages and jet engine nacelles (tubular cylinders).

Slender surfaces[edit]

Slender surfaces are bounded lattices specifically intended to simulate wings. The actual model can be viewed as a paper sheet, but their behavior approaches very well to that of thin wings. Open VOGEL employs this kind of surfaces because they require less than a half of the number of panels required to generate a full 3D model, while they achieve very good results in the prediction of the main air-loads (lift, induced drag and parasitic drag through an experimental polar curve).

Open VOGEL lets designers construct wings by shaping a set of adjacent quadrilateral macro-panels. The software contains a built-in tool to manage the main geometrical parameters (such as dihedral, sweepback, profile and twisting) of each of these macro-panels. This allows users to recreate a very wide variety of models.

Lifting surfaces are modeled with a structured grid characterized by a constant number of chord-wise panels. The user is allowed to refine the mesh by changing the number of chord-wise and span-wise panels. When lifting surfaces are introduced to the calculation model, they are modeled as slender panels. This means that Neumann's boundary conditions (BC) are imposed, and that the lift becomes dependent on the change in tangent velocity across the panel.

Fuselages[edit]

Fuselages in Open VOGEL are lofted surfaces generated from a collection of parallel cross-sections distributed in a longitudinal direction. The resulting mesh is generated by connecting nodal points uniformly distributed around the outline of several virtual cross sections, which are computed by linear interpolation between the user-defined cross-sections.

One or more lifting surfaces can be attached to a fuselage by means of features called anchors. An anchor is a set of slender panels that belong to the fuselage and serve as a bridge between the root of a wing and the panels of the fuselage. Anchors are needed to provide a transition in the circulation of both surfaces, i.e., to properly model a physical connection between both of them. Without anchors, the gap between the two surfaces would leak, creating regions of very high airspeed and a consequent wrong prediction of the air-loads.

The orientation and position of fuselages can be changed as with any other surface, but if one or more lifting surfaces are attached to it, the anchors will only work properly if the fuselage is kept in the original position and orientation (no translation nor rotation applied). Anchoring two or more surfaces to a fuselage is only possible when the surfaces are sufficiently staggered so that they don't share any plane transverse to the fuselage. This limitation is a pure consequence of the meshing technique. When meshing a fuselage, each anchored lifting surface is assigned to a longitudinal chunk of fuselage that is meshed apart, so that the number of longitudinal panels in that longitudinal band matches the number of chord-wise panels of the wing. This method has been represented in the picture here beside.

Fan ducts[edit]

Fan ducts (or jet-engine nacelles) can also be added to the model. In the calculation core these surfaces are managed as slender surfaces, with the exception that drag is not computed.

Calculation capabilities[edit]

Because Open VOGEL is based in the Unsteady Vortex Lattice Method, it can simulate steady and unsteady problems. The unsteady solver is not only used to simulate gusts, but it is the core of the aeroelastic module. By linking a structural FE model with the UVLM, Open VOGEL can also simulate the unsteady transit of flexible wings and the deformation of wings in the steady state.

The aerodynamic calculation core[edit]

Introduction[edit]

Open VOGEL relies on an object-oriented multi-threading calculation core (CC). The aerodynamic part of the CC (the ACC) is based in hierarchical structure of classes that begins with the definition of vortex rings, which in turn, can be assembled together as bricks to form a lattice.

Lattices can be of two types: "bounded" or "free". Bounded lattices represent all solid boundaries where boundary conditions have to be imposed, while free lattices represent the wakes shed by the bounded lattices. Because of this parent-child relation, each bounded lattice contains a stack of wakes that can be automatically shed by its parent bounded lattice based on information about the primitive shedding edges.

Boundary conditions are imposed at vortex ring level. Vortex rings can be triangular or quadrilateral, but most importantly, they can be slender or solid. On slender rings, Neumann boundary conditions are imposed, while on solid rings, Dirichlet boundary conditions are imposed. Imposing one BC or the other implies calculating the local velocity or the local velocity potential.

The calculation of the velocity and the velocity potential at a given point is encapsulated inside the class definition of the vortex rings. The method that is actually implemented differ from the topology of the inducing ring (triangular or quadrilateral). Each lattice exposes then a method that allows the same calculation at lattice level by running over all contained rings.

The ACC will impose the boundary conditions by solving a system of linear equations. In a rigid model-problem, it will build a unique matrix of coefficients, generate the LU decomposition, and reuse that same matrices to find the circulation in the rings at every time step. For aeroelastic simulations, however, because the relative position of the rings is permanently changing due to the deformation of the lattices, the CC will recalculate the influence matrix and LU decomposition at each time step.

The right hand side of the system of equations containing the free-velocity and source-potential terms, is only updated at each time for unsteady problems.

The math behind the software[edit]

Because Open VOGEL deals with several types of panels and boundary conditions, the math and the implemented algorithms are a bit more complex than those required when only working with vortex rings.

The basic problem when dealing with vortex rings is to find out the circulation associated to the rings where the non-penetration boundary condition has to be imposed (the bounded lattices). Because the velocity associated to a vortex ring at a given point depends linearly on the circulation of that ring, a system of linear equations can be written, so that when solved, it will provide the value of the local circulations that will cancel the normal velocity at each control point. The matrix problem for this situation can be found in the article about the vortex lattice method.

Now, when closed bodies such as fuselages need to be modeled, the total potential inside the body is required to equal a given constant value (typically chosen as zero). This is a different kind of problem that requires, first of all, calculating the potential of sink/source and doublet panels at a given point located immediately under the surface of the body, and secondly, arranging the new system of equations in the global matrix problem.

The calculation of the velocity potential associated to constant sink/source panels and vortex rings (constant doublets) at a given point in space is quite complex. Open VOGEL reduces the complexity level by projecting the quadrilateral panels in its normal direction, so that they can be represented by a flat panel (triangular panels do not need to be projected since they are always flat). The calculation of the velocity potential under such situation can be found in this reference.^[2] Of course, this method has some associated leakage, which depends on how well panels are approach by their flat counterpart.

When working with sink/source panels, the intensity vector $\mathbf {s}$ associated to them is not an unknown. In fact, when the internal potential is targeted to zero, their intensity depends on the value of the normal free air-stream velocity:

$s_{i}=-\mathbf {V} _{\infty }\cdot \mathbf {n} _{i}$

Therefore, the unit potential corresponding to each one of them at each control point can be calculated once and stored in a source/sink potential matrix $\mathbf {M} _{s}$ . This matrix is then reused to compute the total sink/source potential when necessary as follows:

$\mathbf {\varphi } _{s}=\mathbf {M} _{s}\mathbf {s}$

The unknowns of the Dirichlet problem are the doublet intensities of each panel surrounding the body, represented here by vector $\mathbf {d}$ . Similarly to the sources, we can write a matrix of unit-intensity potential associated to them:

$\mathbf {\varphi } _{d}=\mathbf {M} _{d}\mathbf {d}$

Finally, the potential associated to the wakes needs to be added. Because wakes are constantly changing their shape, in place of building a matrix, we rather include their potential as a summation of individual contributions:

$\mathbf {\varphi } _{w}=\sum _{j=1}^{N}\varphi _{wi}$

Because wakes are shed from lifting surfaces, their potential is only associated to constant doublet panels of known intensity. When wake panels are far enough from the body, they can be approached by point doublets, which have much simpler potential functions. This solution is known as the far field potential.

The Dirichlet problem is then represented by the next system or linear equations

$\mathbf {M} _{d}\mathbf {d} =-\mathbf {M} _{s}\mathbf {s} -\sum _{j=1}^{N}\varphi _{wi}$

which needs to be assembled and solved together with the Neumann problem in a global matrix problem.

Multi-threading operation[edit]

When the velocity or velocity-potential has to be calculated at all control points in a bounded lattice, a multi-threading operation is started: for each control point in the targeting lattice, all rings from all bounded lattices and associated wakes are run over in an isolated thread. This multi-threading system allows running several vortex rings simultaneously, what considerably reduces the calculation time in multiple-cores machines. The reduction of time is proportional to the number of processors in the machine.

The next lines of code show how the parallelization works.

Private Sub CalculateVelocityInducedByTheWakesOnBoundedLattices(Optional ByVal SlenderRingsOnly As Boolean = True)
    Dim CutOff As Double = Settings.Cutoff
    For Each Lattice As BoundedLattice In Lattices
        Parallel.ForEach(Lattice.VortexRings, Sub(VortexRing As VortexRing)
                                                  If (SlenderRingsOnly And VortexRing.IsSlender) Or Not SlenderRingsOnly Then
                                                      VortexRing.VelocityW.X = 0.0#
                                                      VortexRing.VelocityW.Y = 0.0#
                                                      VortexRing.VelocityW.Z = 0.0#
                                                      For Each OtherLattice As BoundedLattice In Lattices
                                                          For Each Wake As Wake In OtherLattice.Wakes
                                                              Wake.AddInducedVelocity(VortexRing.VelocityW, VortexRing.ControlPoint, CutOff)
                                                          Next
                                                      Next
                                                  End If
                                              End Sub)
    Next
End Sub

The whole code is located in a GitHub repository.^[3]

Aeroelastic capabilities[edit]

Open VOGEL counts with an integrated aeroelastic module that allows treating the interaction between a beam-based structure and a slender surface. This interaction is simulated by dynamic mode decomposition and numerical integration in the time-domain.

References[edit]

↑ OpenVOGEL (openvogel.org)
↑ "Low speed aerodynamics", Allen Plotkin, Joseph Katz
↑ Open VOGEL code repository https://github.com/OpenVOGEL/OpenVOGEL

This article "Open VOGEL" is from Wikipedia. The list of its authors can be seen in its historical and/or the page Edithistory:Open VOGEL. Articles copied from Draft Namespace on Wikipedia could be seen on the Draft Namespace of Wikipedia and not main one.

[1] OpenVOGEL (openvogel.org)

[2] "Low speed aerodynamics", Allen Plotkin, Joseph Katz

[3] Open VOGEL code repository https://github.com/OpenVOGEL/OpenVOGEL

[1]

[2]

[3]