Simulation settings

Sim

A mutable struct representing the simulation settings.

Fields

• floris::String: The name of the FLORIS model to be used.
• start_time::Int64: The start time of the simulation in seconds.
• end_time::Int64: The end time of the simulation in seconds.
• time_step::Int64: The time step for the simulation in seconds.
• sim_step::Union{Nothing, Int64}: Optional simulation step size.
• n_sim_steps::Union{Nothing, Int64}: Optional number of simulation steps.
• rotor_discret::String: The rotor discretization method, e.g., "Uniform", "Gaussian".
• rotor_points::Int64: The number of rotor points for discretization.
• dyn::Dyn: The dynamic settings for the simulation.
• init::String: The initialization method, e.g., "init", "load".
• path_to_data::String: The path to the directory where simulation data is stored.
• save_init_state::Bool: Whether to save the initial state of the simulation.
• save_final_state::Bool: Whether to save the final state of the simulation.

Wind

A mutable struct representing wind settings.

Fields

• input_vel::String: The type of wind velocity input, e.g., "Constant", "Interpolation".
• input_dir::String: The type of wind direction input, e.g., "Constant", "Interpolation".
• input_ti::String: The type of turbulence intensity input, e.g., "Constant", "Interpolation".
• input_shear::String: The type of wind shear input, e.g., "PowerLaw", "Interpolation".
• correction::WindCorrection: Settings for wind corrections.
• perturbation::WindPerturbation: Settings for wind perturbations.
• vel::Union{Nothing, Float64}: Optional wind velocity value.
• dir::Union{Nothing, Matrix{Float64}, WindDirMatrix, WindDirType, WindDirTriple}: Optional wind direction matrix or covariance data.
• ti::Union{Nothing, Float64}: Optional turbulence intensity value.
• shear::Union{Nothing, WindShear}: Optional wind shear profile.

Con

A mutable struct for configuration settings.

Fields

• yaw::String: The yaw control strategy, e.g., "Constant", "Interpolation".
• yaw_data::Union{Nothing, Matrix{Float64}}: Optional yaw data matrix.
• tanh_yaw::Bool: Whether to use hyperbolic tangent yaw control.

Vis

A mutable struct for visualization settings in wind farm simulations.

This struct controls visualization options during simulation runtime, particularly for live plotting and animation features. It provides both stored fields and computed properties for flexible path management.

Fields

• online::Bool: Enable/disable online visualization during simulation. When true, live plots and animations are displayed during the simulation run. When false, visualization is disabled for faster computation.
• save::Bool: Enable/disable saving of plots to disk. When true, plots are saved to disk in PNG format. When false, plots are only displayed (default: false).
• print_filenames::Bool: Enable/disable printing of saved filenames to console. When true, filenames of saved plots are printed (default: false).
• video_folder::String: Relative path for the video output directory. Used when online=true and save=true (default: "video").
• fps::Int: Frames per second for video output when creating videos from saved frames. Controls the playback speed of generated MP4 videos (default: 12).
• output_folder::String: Relative path for the output directory. Used when online=false and save=true (default: "out").
• unique_output_folder::Bool: If true, a unique timestamped folder is created for each simulation run. If false, files are saved directly to the output folder (default: true).
• flow_fields::Vector{FlowField}: List of flow field visualizations to be created. Each FlowField contains configuration for name, online display, video creation, and skip control. See FlowField for details (default: FlowField[]).
• measurements::Vector{Measurement}: List of measurement visualizations to be created. Each Measurement contains configuration for name, separated plotting, and skip control. See Measurement for details (default: Measurement[]).
• v_min::Float64: Minimum velocity value for color scale in effective wind speed visualizations (msr=EffWind). Used to set consistent color scale limits across animation frames (default: 2.0).
• v_max::Float64: Maximum velocity value for color scale in effective wind speed visualizations (msr=EffWind). Used to set consistent upper limits across animation frames (default: 10.0).
• rel_v_min::Float64: Minimum relative velocity value for velocity reduction visualizations (msr=VelReduction). Controls the color scale for relative wind speed plots. Range: [0, 100] (default: 20.0).
• rel_v_max::Float64: Maximum relative velocity value for velocity reduction visualizations (msr=VelReduction). Controls the upper limit for relative wind speed plots. Range: [0, 100] (default: 100.0).
• turb_max::Float64: Maximum turbulence value for added turbulence visualizations (msr=AddedTurbulence). Controls the upper limit for turbulence plots (default: 35.0).
• up_int::Int: Update interval - controls how frequently visualization updates occur. Higher values result in less frequent updates for better performance (default: 1).
• unit_test::Bool: Enable unit test mode for visualization functions. When true, plots are automatically closed after 1 second for testing purposes (default: false).

Computed Properties

• video_path::String: Full absolute path to the video directory. Automatically creates the directory if it doesn't exist. Path is environment-dependent: ~/scratch/video_folder on Delft Blue, pwd()/video_folder elsewhere.
• output_path::String: Full absolute path to the output directory. Automatically creates the directory if it doesn't exist. Path is environment-dependent: ~/scratch/output_folder on Delft Blue, pwd()/output_folder elsewhere.

Constructors

# Default constructor with keyword arguments
vis = Vis(online=true, save=true, v_min=2.0, v_max=12.0)

# Constructor from YAML file
vis = Vis("path/to/config.yaml")  # Loads from data["vis"] section

Examples

# Enable online visualization with plot saving and custom color scales
vis = Vis(online=true, save=true, v_min=2.0, v_max=12.0, rel_v_min=20.0, rel_v_max=100.0, up_int=5)

# Display only, no saving with default color scales
vis = Vis(online=true, save=false, v_min=2.0, rel_v_min=20.0)

# Specify flow field and measurement visualizations to create
flow_fields = [FlowField("flow_field_vel_reduction", true, true), FlowField("flow_field_added_turbulence", false, false)]
measurements = [Measurement("msr_vel_reduction", true), Measurement("msr_added_turbulence", false)]
vis = Vis(online=true, save=true, flow_fields=flow_fields, measurements=measurements)

# Disable online visualization for batch processing
vis = Vis(online=false, save=false)

# Load from YAML configuration (automatically parses flow_fields and measurements)
vis = Vis("data/vis_default.yaml")

# Access computed properties (creates directories automatically)
println("Saving plots to: ", vis.video_path)  # When online=true
println("Output directory: ", vis.output_path) # When online=false

YAML Configuration Format

When loading from YAML files, the flow_fields and measurements are automatically parsed:

vis:
  online: true
  save: true
  flow_fields:
    - name: "flow_field_vel_reduction"
      online: true
      create_video: true
      skip: false
    - "flow_field_added_turbulence"  # Simple format, defaults applied
  measurements:
    - name: "msr_vel_reduction" 
      separated: true
      skip: false
    - "msr_added_turbulence"  # Simple format, defaults applied

File Saving Behavior

When save=true, plots are saved as PNG files with descriptive names:

• ff_velocity_reduction.png - for velocity reduction plots (msr=VelReduction)
• ff_added_turbulence.png - for turbulence intensity plots (msr=AddedTurbulence)
• ff_wind_speed.png - for effective wind speed plots (msr=EffWind)
• Time-stamped versions: ff_velocity_reduction_t0120s.png when time parameter is provided

Save location depends on the online setting:

• online=true: Files saved to video_path (for animations)
• online=false: Files saved to output_path (for final results)

Performance Notes

• Online visualization significantly slows down simulation performance
• Useful for debugging, monitoring simulation progress, or creating videos of the simulation
• When disabled, visualization functions are skipped to improve computational efficiency
• up_int can be used to reduce visualization frequency and improve simulation speed
• Directory creation is automatic but occurs only when computed properties are accessed
• Flow fields and measurements with skip=true are ignored completely for optimal performance

Environment Adaptation

The struct automatically adapts to different computing environments:

• Delft Blue supercomputer: Uses ~/scratch/ directory for ample storage space
• Local systems: Uses current working directory (pwd())
• Detection is automatic via the isdelftblue() function

See Also

• FlowField: Configuration struct for flow field visualizations
• Measurement: Configuration struct for measurement visualizations
• parse_flow_fields: Function to convert YAML flow field configurations
• parse_measurements: Function to convert YAML measurement configurations

Floris

A mutable struct representing the settings for the FLORIDyn simulation.

Fields

• alpha::Float64: The alpha parameter for the FLORIS model.
• beta::Float64: The beta parameter for the FLORIS model.
• k_a::Float64: The k_a parameter for the FLORIS model.
• k_b::Float64: The k_b parameter for the FLORIS model.
• k_fa::Float64: The k_fa parameter for the FLORIS model.
• k_fb::Float64: The k_fb parameter for the FLORIS model.
• k_fc::Float64: The k_fc parameter for the FLORIS model.
• k_fd::Float64: The k_fd parameter for the FLORIS model.
• eta::Int: The eta parameter for the FLORIS model.
• p_p::Float64: The p_p parameter for the FLORIS model.
• airDen::Float64: The air density for the FLORIS model.
• TIexp::Int: The turbulence intensity exponent for the FLORIS model.
• rotor_points::Union{Nothing, Int64}: Optional number of rotor points.

FloriDyn

A structure representing the settings for the FLORIDyn simulation environment.

Fields

• n_op::Int: The number of operating points.
• deltaUW::Float64: The delta U wind speed perturbation.
• deltaDW::Float64: The delta D wind direction perturbation.
• deltaCW::Float64: The delta C wind turbulence intensity perturbation.
• dynStateChange::String: The type of dynamic state change, e.g., "Constant", "Interpolation".
• twf_model::String: The type of TWF (Turbine Wake Flow) model used, e.g., "Gaussian", "FLORIDyn".

TurbineArray

A structure representing the configuration and properties of a wind turbine array.

Fields

• pos::Matrix{Float64}: A matrix containing the positions of turbines. Each row represents a turbine with columns for x, y, and z coordinates (in meters).
• type::Vector{String}: A vector of strings specifying the type/model of each turbine.
• init_States::Matrix{Float64}: A matrix containing the initial states of each turbine. Each row represents a turbine with columns for: - Column 1: a - axial induction factor - Column 2: yaw - initial yaw angle (in degrees) - Column 3: ti - turbulence intensity

Example

# Create a simple 2-turbine array
pos = [0.0 0.0 0.0; 500.0 0.0 0.0]  # Two turbines 500m apart
type = ["NREL_5MW", "NREL_5MW"]
init_states = [0.33 0.0 0.1; 0.33 0.0 0.1]  # Both start with same initial conditions
turbines = TurbineArray(pos, type, init_states)

TurbineData

A structure containing technical specifications for wind turbines.

Fields

• nac_pos::Matrix{Float64}: An N × 3 matrix where each row corresponds to the (x, y, z) coordinates of the nacelle position for each turbine in meters.
• rotor_diameter::Vector{Float64}: A vector of rotor diameters corresponding to each turbine in meters.

Example

# Get turbine data for specific types
names = ["DTU 10MW", "V116", "GE Haliade X"]
turbine_data = getTurbineData(names)
println("First turbine nacelle height: ", turbine_data.nac_pos[1, 3], " m")
println("First turbine rotor diameter: ", turbine_data.rotor_diameter[1], " m")

FlowField

Structure representing a single flow field visualization configuration.

This struct defines the configuration for individual flow field visualizations, including the flow field type, online visualization settings, video creation options, and skip control.

Fields

• name::String: The name/identifier of the flow field type (e.g., "flow_field_vel_reduction", "flow_field_added_turbulence", "flow_field_eff_wind_speed")
• online::Bool: Whether the flow field should be displayed during online visualization (true) or only saved offline (false). Default is false for offline-only processing.
• create_video::Bool: Whether to create a video from the flow field frames (true) or not (false). Default is false for no video creation.
• skip::Bool: Whether to skip processing of this flow field entirely (true) or process normally (false). Default is false for normal processing. When true, the flow field will be ignored completely.

Examples

# Velocity reduction flow field with online display and video creation
vel_field = FlowField("flow_field_vel_reduction", true, true)

# Turbulence flow field with offline-only processing, no video
turb_field = FlowField("flow_field_added_turbulence", false, false)

# Flow field that should be skipped entirely
skipped_field = FlowField("flow_field_eff_wind_speed", false, false, true)

# Using keyword arguments
eff_field = FlowField(name="flow_field_eff_wind_speed", online=false, create_video=true, skip=false)

See Also

• parse_flow_fields: Function to convert YAML flow field configurations to FlowField arrays
• plotFlowField: Function that uses these configurations for visualization

Measurement

Structure representing a single measurement visualization configuration.

This struct defines the configuration for individual measurement visualizations, including the measurement type, whether it should be displayed in separated plots, and skip control.

Fields

• name::String: The name/identifier of the measurement type (e.g., "msr_vel_reduction", "msr_added_turbulence", "msr_eff_wind_speed")
• separated::Bool: Whether the measurement should be plotted in separate individual plots (true) or combined in a single plot (false). Default is false for combined plotting.
• skip::Bool: Whether to skip processing of this measurement entirely (true) or process normally (false). Default is false for normal processing. When true, the measurement will be ignored completely.

Examples

# Velocity reduction measurement with separated plots
vel_measurement = Measurement("msr_vel_reduction", true)

# Turbulence measurement with combined plots  
turb_measurement = Measurement("msr_added_turbulence", false)

# Measurement that should be skipped entirely
skipped_measurement = Measurement("msr_eff_wind_speed", false, true)

# Using keyword arguments
eff_measurement = Measurement(name="msr_eff_wind_speed", separated=false, skip=false)

See Also

• parse_measurements: Function to convert YAML measurement configurations to Measurement arrays
• plotMeasurements: Function that uses these configurations for visualization

install_examples(add_packages=true)

Install example files, executables, and data files for the FLORIDyn.jl package.

This function sets up a complete working environment by copying:

• Example Julia scripts from the package's examples directory (via copy_examples)
• Executable scripts (like run_julia) to a local bin directory (via copy_bin)
• Model configuration files and data to a local data directory (via copy_model_settings)

Arguments

• add_packages::Bool=true: Whether to automatically install additional required packages ("LaTeXStrings", "Timers") that are commonly used in the examples

Example

# Install examples with automatic package installation
install_examples()

# Install examples without installing additional packages
install_examples(false)

After running this function, you can:

• Run example scripts from the created examples/ directory
• Execute ./bin/run_julia to start Julia with the project environment
• Access model data files in the data/ directory

See also: copy_examples, copy_bin, copy_model_settings

copy_examples()

Copy all example scripts to the folder "examples" (it will be created if it doesn't exist).

copy_model_settings()

Copy model configuration files and data directories to the local data directory.

This function copies essential model configuration files and simulation data from the package's data directory to a local data/ directory in the current working directory.

Files and Directories Copied

Configuration File

• 2021_9T_Data.yaml: Main wind farm configuration file containing turbine layout, simulation parameters, and model settings

Data Directory

• 2021_9T_Data/: Complete SOWFA simulation data directory containing:
  • SOWFA_bladePitch.csv: Blade pitch angle time series
  • SOWFA_generatorPower.csv: Generator power output data
  • SOWFA_generatorTorque.csv: Generator torque measurements
  • SOWFA_nacelleYaw.csv: Nacelle yaw angle data
  • SOWFA_rotorSpeedFiltered.csv: Filtered rotor speed measurements
  • U.csv, WindVel.csv: Wind velocity data
  • WindDir.csv, WindDirConstant.csv: Wind direction measurements
  • WindTI.csv, WindTIConstant.csv: Turbulence intensity data
  • Additional covariance and profile files

Automatic Operations

The function automatically:

• Creates the data/ directory if it doesn't exist
• Copies the main YAML configuration file using copy_files
• Recursively copies the entire 2021_9T_Data/ subdirectory with all CSV files
• Sets proper file permissions (0o774) on all copied files

This function is called as part of install_examples to set up a complete working environment with all necessary configuration files and simulation data.

See also: copy_files, install_examples

copy_bin()

Copy the script run_julia to the folder "bin" (it will be created if it doesn't exist).

copy_files(relpath, files)

Copy a list of files from the package directory to a local directory.

This utility function copies files from the package's source directory structure to a corresponding local directory. It automatically handles directory creation and sets appropriate file permissions.

Arguments

• relpath::String: The relative path (directory name) within both the package and local filesystem where files should be copied
• files::Vector{String}: A vector of filenames to copy from the source to destination

Details

The function:

• Creates the destination directory (relpath) if it doesn't exist
• Copies each file from <package_dir>/<relpath>/<file> to ./<relpath>/<file>
• Sets executable permissions (0o774) on all copied files
• Overwrites existing files (uses force=true)

Returns

• Vector{String}: The list of files that were copied (same as input files)

Example

# Copy specific example files to local examples directory
copy_files("examples", ["main.jl", "menu.jl"])

# Copy data files to local data directory  
copy_files("data", ["config.yaml", "turbine_data.csv"])

This function is used internally by copy_examples, copy_model_settings, and other file copying utilities.

See also: copy_examples, copy_model_settings, copy_bin

setup(filename) -> (wind, sim, con, floris, floridyn, ta)

Load wind farm configuration from a YAML file and parse all simulation components.

This function reads the configuration file of the simulation and extracts all necessary parameters for setting up a FLORIDyn simulation, including wind conditions, simulation settings, control strategies, FLORIS model parameters, FLORIDyn dynamics, and turbine array layout.

Arguments

• filename::String: Path to the YAML configuration file. The file should contain sections for: wind, sim, con, floris, floridyn, and turbines.

Returns

A 6-tuple containing fully configured simulation components:

• wind::Wind: Wind conditions and input specifications (velocity, direction, turbulence, shear, corrections, perturbations)
• sim::Sim: Simulation parameters (time range, discretization, dynamics, initialization, data paths)
• con::Con: Control settings (yaw strategies, control data)
• floris::Floris: FLORIS wake model parameters (alpha, beta, k coefficients, air density, etc.)
• floridyn::FloriDyn: FLORIDyn dynamic model settings (operating points, perturbations, state changes)
• ta::TurbineArray: Turbine array configuration (positions, types, initial states)

YAML File Structure

The configuration file must contain these top-level sections:

wind:          # Wind input specifications and corrections
sim:           # Simulation time, discretization, and dynamics  
con:           # Control strategies and yaw data
floris:        # FLORIS model coefficients and parameters
floridyn:      # FLORIDyn dynamic model settings
turbines:      # Array of turbine definitions with position, type, initial states

Example

# Load complete wind farm configuration
wind, sim, con, floris, floridyn, ta = setup("data/2021_9T_Data.yaml")

# Access turbine positions  
println("Number of turbines: ", size(ta.pos, 1))
println("Simulation duration: ", sim.end_time - sim.start_time, " seconds")

See Also

• Wind: Wind conditions and input specifications
• Sim: Simulation parameters and settings
• Con: Control configuration
• Floris: FLORIS wake model parameters
• FloriDyn: FLORIDyn dynamic model settings
• TurbineArray: Turbine array layout and properties

Settings

A mutable struct that holds configuration parameters for the FLORIDyn simulation environment.

Fields

• vel_mode::VelModel: See: VelModel
• dir_mode::DirModel: See: DirModel
• turb_mode
• shear_mode
• cor_dir_mode
• cor_vel_mode
• cor_turb_mode
• iterate_mode
• control_mode
• parallel::Bool: Run plotting in a separate process.
• threading::Bool: Enable threading for parallel computation within a single process

Settings(wind::Wind, sim::Sim, con::Con, parallel=false, threading=false)

Create and return a Settings object using the provided wind and sim parameters.

Arguments

• wind::Wind: An instance of the Wind struct containing wind-related parameters.
• sim::Sim: An instance of the Sim struct containing the simulation parameters.
• con::Con: An instance of the Con struct containing the controller parameters.
• parallel::Bool: Enable plotting in a separate process (default: false)
• threading::Bool: Enable threading for parallel computation within a single process (default: false)

Returns

• A Settings struct configured with the given wind and simulation parameters.

Notes

• The function uses the str2type helper to convert string representations of model types into their corresponding Julia types.
• The Settings struct encapsulates the model settings for velocity, direction, turbulence intensity, shear, and correction modes.

getTurbineData(names::Vector{String}) -> TurbineData

Retrieve nacelle positions and rotor diameters for a given list of wind turbine types.

Arguments

• names::Vector{String}: A vector of wind turbine type names. Supported types are loaded from the data/turbine_specs.yaml file and currently include:
  • "DTU 10MW"
  • "DTU 5MW"
  • "Senvion 6.2M"
  • "V116"
  • "V117"
  • "V162"
  • "GE Haliade X"

Returns

• A TurbineData struct with the following fields:
  • nac_pos::Matrix{Float64}: An N × 3 matrix where each row corresponds to the (x, y, z) coordinates of the nacelle position for each turbine.
  • rotor_diameter::Vector{Float64}: A vector of rotor diameters corresponding to each turbine.

Raises

• ArgumentError if an unknown or misspelled turbine name is encountered.

Example

names = ["DTU 10MW", "V116"]
turbine_data = getTurbineData(names)
println("Nacelle positions: ", turbine_data.nac_pos)
println("Rotor diameters: ", turbine_data.rotor_diameter)

Data Source

Turbine specifications are loaded from data/turbine_specs.yaml. To add new turbine types, add entries to this file following the existing format.

parse_measurements(measurements_yaml::Vector) -> Vector{Measurement}

Convert YAML measurement configurations into an array of Measurement structs.

This function parses the measurement section from a YAML visualization configuration and converts it into a structured array of Measurement objects. It handles both simple string entries and complex dictionary entries with name, separated, and skip flag specifications.

Arguments

• measurements_yaml::Vector: Vector containing measurement configurations from YAML. Each element can be either:
  • A simple string (measurement name)
  • A dictionary with "name", "separated", and "skip" keys

Returns

• Vector{Measurement}: Array of Measurement structs with parsed configurations

YAML Format Support

The function supports multiple YAML formats:

Simple Format (separated=false, skip=false by default)

measurements:
  - "msr_vel_reduction"
  - "msr_added_turbulence" 

Extended Format (with separated and skip flags)

measurements:
  - name: "msr_vel_reduction"
    separated: true
    skip: false
  - name: "msr_added_turbulence"
    separated: false
    skip: true

Mixed Format

measurements:
  - "msr_vel_reduction"           # Simple string, defaults applied
  - name: "msr_added_turbulence"  # Dictionary format
    separated: true
    skip: false

Algorithm

1. Iterate through each measurement entry in the YAML vector
2. Check type: Determine if entry is string or dictionary
3. Extract values: Get name, separated, and skip flags based on format
4. Create struct: Construct Measurement struct with parsed values

Error Handling

• Handles missing separated and skip flags by defaulting to false
• Processes mixed simple/complex YAML structures gracefully
• Validates measurement name extraction

Examples

# Parse from YAML data
yaml_measurements = [
    "msr_vel_reduction",
    Dict("name" => "msr_added_turbulence", "separated" => true, "skip" => false)
]

measurements = parse_measurements(yaml_measurements)
# Returns: [Measurement("msr_vel_reduction", false, false), 
#          Measurement("msr_added_turbulence", true, false)]

See Also

• Measurement: The struct type created by this function
• Vis: Visualization settings struct that uses these measurements
• plotMeasurements: Function that consumes these measurement configurations

parse_flow_fields(flow_fields_yaml::Vector) -> Vector{FlowField}

Convert YAML flow field configurations into an array of FlowField structs.

This function parses the flow_fields section from a YAML visualization configuration and converts it into a structured array of FlowField objects. It handles both simple string entries and complex dictionary entries with name, online, create_video, and skip flag specifications.

Arguments

• flow_fields_yaml::Vector: Vector containing flow field configurations from YAML. Each element can be either:
  • A simple string (flow field name)
  • A dictionary with "name", "online", "create_video", and "skip" keys

Returns

• Vector{FlowField}: Array of FlowField structs with parsed configurations

YAML Format Support

The function supports multiple YAML formats:

Simple Format (online=false, create_video=false, skip=false by default)

flow_fields:
  - "flow_field_vel_reduction"
  - "flow_field_added_turbulence" 

Extended Format (with online, create_video, and skip flags)

flow_fields:
  - name: "flow_field_vel_reduction"
    online: true
    create_video: true
    skip: false
  - name: "flow_field_added_turbulence"
    online: false
    create_video: false
    skip: true

Mixed Format

flow_fields:
  - "flow_field_vel_reduction"           # Simple string, defaults applied
  - name: "flow_field_added_turbulence"  # Dictionary format
    online: true
    create_video: false
    skip: false

Examples

# Parse from YAML data
yaml_flow_fields = [
    "flow_field_vel_reduction",
    Dict("name" => "flow_field_added_turbulence", "online" => true, "create_video" => false, "skip" => true)
]

flow_fields = parse_flow_fields(yaml_flow_fields)

See Also

• FlowField: The struct type created by this function
• parse_measurements: Similar function for measurement configurations