Running NuMAD
The following sections go through the basics of putting together and analyzing a blade design in NuMAD, from creating a blade object, to modifying its parameters and attributes, and generating structural models for analysis. Tips for implementation are given to ensure the smoothest execution.
Blade Generation
There are several ways to construct a blade model in NuMAD 3.0. In many ways the most intuitive approach is by using the graphical user interface carried over from NuMAD 2.0 (for detailed instructions, please refer to the NuMAD 2.0 user manual [3]). Although the current version is designed not to be reliant on this GUI, it is still supported and can be a useful tool if designing a blade model from scratch.
A more automated way to generate a blade model is by reading a .yaml
file, and using the data stored within to populate the model definition.
The .yaml
format contains all the geometric, aerodynamic and material
information needed to define a blade structure, and is widely used in
the field, making it a convenient choice for the source data file.
Several examples of .yaml
files are provided in the NuMAD/examples/referenceModels
directory
of the GitHub repository.
To read a .yaml
file’s data into NuMAD from a MATLAB script or command
window, first save the .yaml
file in the working directory for the blade
model. Typically, each blade design should have its own working
directory, which contains aerodynamic/airfoil data, FAST input files
(*.fst
extension) and subfolders for NuMAD operations and FAST
simulation output files (*.out
extension). Once the .yaml
file is saved
alongside these items, it can be read by creating a new blade object of
type BladeDef
and calling the reader function, as shown:
>> blade = BladeDef
>> blade.readYAML(<yamlfilename>)
After entering these commands, the blade model data will be stored in
the object called blade
, which can be printed out and modified as
desired as further explained in Blade Variable Assignment. Many types of analysis and
operations can be performed once a blade model is stored as a blade
object in this way.
If it is desired to run aeroelastic simulation with
runIEC
, or to generate loads from FAST-generated output files as
described in Finite Element Analysis Operations, it is advisable to update the FAST input files
in the blade’s main working directory to ensure that certain quantities
within are consistent with the data stored in the .yaml
file, such as
prebend, presweep, and structural twist. This can be done using the
commands
>> IEC = IECdef(inputFileName)
>> updateFASTFromBLADEDef(IEC,blade)
inputFileName
refers to the path/name of the input file containing variables
related to the aeroelastic analysis and simulation (see Run Aeroelastic Simulations to Analyze IEC-Standard Design Load Cases for more
details).
After all desired analyses and modifications are complete, a new,
updated .yaml
file can be generated to represent the optimized, or
re-designed blade. To do this issue the command:
>> writeYAML(blade,<newyamlfilename>);
The new file name should be of the form <originalfile>_mod.yaml
, adding
an _mod
extension to the name of the original .yaml
file from which
the blade model was generated. The new file will be written into the
blade model’s working directory alongside the original.
Generating blades from .yaml
files is useful for streamlining analysis
and optimization processes, since all operations can be called from a
MATLAB script, without depending on the graphical user interface or any
manual input during execution.
Blade Variable Assignment
Any blade design process involves setting and modifying characteristics
of the blade’s geometric, structural, and material properties in some
way. The NuMAD blade object contains a collection of variables that
represent these properties, and can be set and modified by value
assignment within a MATLAB script or in the command line. A
comprehensive list of all public variables in the BladeDef
class used in
NuMAD is given in the Object Classes, Properties, and Methods.
Here we give some highlighted examples of key variables within the blade
object and their basic access. The overall shape of the blade is defined
largely by the stations (access: blade.stations
). Each station
contains several variables whose values can be edited. For instance, if
a blade model was generated by reading a .yaml
file as described in
Blade Generation, and it was desired to set the spanwise position of the
second station at 3.5 meters, the command
>> blade.stations(2).spanlocation = 3.5
could be used. Many variables are arrays with multiple values, and can be set according using standard MATLAB syntax. The coordinates of the points defining the outer airfoil shape at a given station, for example, are stored in the airfoil object at each individual station as an \(N X 2\) array, and can be set as follows:
>> blade.stations(2).airfoil.coordinates = [X1, Y1; X2, Y2; ...; XN, YN]
There are several properties that each define some aspect of the blade’s shape with a value at any given spanwise location, including chord length, angle of twist, aerodynamic center, sweep and prebend. These can be set at any number of spanwise points, with the variable span specifying their locations. If a user wanted to, say, set the prebend of the blade to some constant \(k\) times cube of the spanwise location, specified at 10 equally spaced points, they could set
>> blade.span = linspace(0,<bladeLength>,10);
>> blade.prebend = k*blade.span.^3;
The bulk of the structural properties of the blade’s components are
stored in blade.components
variable. A single component contains a name,
a material ID number, labels representing the points it spans between
according to Fig. 1, and a control point array, called cp
. The
control point array specifies the thickness of the given component at
every spanwise location, expressed in number of layers (the actual
thickness of a layer is defined by the material object it corresponds
to, shown shortly). Suppose component 3 in the blade was the suction
side spar cap, and it was desired to vary the thickness linearly from 10
layers at the root to 2 layers at the tip, say 50 meters span. The user
could set
>> blade.components(3).cp = [0, 10; 50, 2];
The width of the spar caps and the leading edge and trailing edge bands
are single nominal values for the entire length of the blade, stored in
the variables blade.sparcapwidth
, blade.leband
and blade.teband
respectively.
The data defining the properties of all the materials used throughout
the blade are stored in the variable blade.materials
. Each entry in
blade.materials
is a MaterialDef
object, which stores a name, elastic
properties, density, and strength properties among others (see Material Class in the Object Classes, Properties, and Methods).
It also stores the thickness that a single layer of that material in a
composite is assumed to be, which can be important to know or edit when
defining the thickness distribution of the blade’s components as just described.
After editing the design properties of a blade model as illustrated in these few examples, a user should run the command
>> blade.UpdateBlade()
This function updates numerous internal private variables based on the
edited values in the public variables. Among other things, it
interpolates the properties that vary along the span of the blade to the
spanwise points specified in the variable blade.ispan
. These include
all the properties defined in blade.stations
, as well as the general
spanwise properties such as prebend, twist, etc. UpdateBlade
also
updates the bill of materials for the blade, stored in blade.bom
and
various details of the geometry, stored in blade.geometry
.
When the variables defining the blade design are set to satisfaction, the blade object can be used to perform various operations for analysis and optimization, such as generating representative structural models as described in the next section.
Generating Representative Blade Structural Models
A NuMAD blade object can be used to construct structural models for various types of analysis. Several tools exist that analyze characteristics such as section stiffness, mass, and natural frequencies of wind blades by representing them with low-fidelity beam models. These include PreComp, BModes, and BPE. The most straightforward way of invoking these capabilities is through the graphical user interface (for details please see ref. [3]).
In addition to these, however, NuMAD 3.0 has many built-in functions for performing high-fidelity analysis of a blade as a shell-element model in ANSYS, which are easily invokable from a MATLAB script or command line. These include analysis for maximum tip deflection, ultimate rupture failure, global and local buckling, fatigue and natural frequencies and are discussed in detail in Finite Element Analysis Operations.