WindTurbine simulation

[Zollhafen]

Hello everyone,

I am configuring a setup for a WindTurbine simulation, with precalculated aifoilpolars and contours.
I already know that this is possible through the validation studies made by Ed Alvarez.

For the WEA the suction and pressure side of the rotor need to be reversed compared to the classical case. But would this mean I also need to inverse the calculation of lift or C_l?

You see I am encountering some issues because I am not yet completely familiar with the calculation process in the rVPM.

Before diving into it I wanted to check if someone has already successfully put FLOWUnsteady in "Power generation" mode and can pinpoint at what locations I need to make adjustments or if there are already implemented parameters that adjust the solver to this.

Thank you and best regards

[Lullaby-star]

Hi Zollhafen,

I'm also quite new to using FLOWUnsteady for wind turbine simulations and am facing some issues with setting up the simulation. Did you succeed in setting up this simulation? If yes, could you please share the .jl file you used or perhaps help me set up a new one?

The main problem I'm encountering seems to be related to the turbine_flag and geometry generation. I've set both the CW_flag and the turbine_flag to true, but the geometry I get appears incorrect: the leading edge (LE) of the lattice is not facing the flow, and at the root, the elements collapse.

After several attempts, I managed to create a correct geometry, but only by setting the turbine_flag to false and the CW_flag to true (I compared the lattice I obtained with the one shown in QBlade). However, I think this approach is completely wrong because it treats the turbine as a propeller.

Thank you in advance for your help.

Best regards

[Zollhafen]

Hey,

sorry for the late answer.
yes I did get the simulation working to a satisfying degree, but not perfect.
I also encounterd some of the issues you are describing.

You can see my Setup file at the end. Even though I had to make some canges to the FLOWVLM Package. I flipped the sign of the effective angle of attack before the c_l value is pulled from the Polar. (in FLOWVLM_rotor.jl in the function _calc_distributedLoads_lookuptable I changed

Effective angle of attack (rad)

thetaV = atan(Vx, Vy)
thetaeff = (thetaV - twist)*(-1)

thetaeffdeg[i] = thetaeff*180/pi
# println("angles = $([twist, thetaeff]*180/pi)\tVx,Vy=$([Vx, Vy])"))

to then get the right c_l I also flipped the sign of my Polar to negative. I don't know if this is because I did not apply the Turbine Flag correctly or whats the cause for this, but I noticed that's the way I get the correct c_l and c_d values across the blade.

Following, some things to look at:
-Whether the wake_coupled flag is set to true or false the Bladeforces get calculated with a different solver. Once with vlm.solvefromV and once vlm.solvefromCCBlade. As far as I can tell the Turbine Flag is handled a bit differently in both of them, even though I could'nt grasp the different implications of the Turbine Flag in full completion

-To check if the c_l and c_d values are correct for you case, I recommend passing the debug=true flag in the uns.run_simulation. This will show you the spanwise c_l and c_d values at every timestep in your Blade result files

-Your geometry problem could result from the fact that as far as I can remember the Turbine Flag does not change the geometry of your Blade. (Turn the Flag on and off and check if the Geometry changes). That way when you adjust your geometry so that it fits the Windturbine and you turn on the Flag it will behave as a Propeller. (Not sure anymore about this point, as you say you can only model the geometry correctly without the turbine_flag, so you might have to double check my answer to that)
I have no experience with the CW_flag

-For my case, my polars already included Hub and Tip losses and Mach and 3D corrections. The latter two cannot be disabled via a Flag in FLOWUnsteady and you have to disable them manually if you want to do so (FLOWVLM roto_ccb.jl FLOWVLM2OCCBlade)

I hope I could help.
Best regards.

import FLOWUnsteady as uns
import FLOWVLM as vlm
import FLOWVPM as vpm
import FLOWUnsteady: vpm, gt, dot, norm

#config wHUB_postwist_negcl_turbon_woALLcorrection_negtheta_posalpha

Height VonTopVerlauf_sign_rev

run_name = "Wind_turbine" # Name of this simulation

save_path = joinpath(".", run_name) # Adjust the path accordingly

paraview = false # Whether to visualize with Paraview

----------------- GEOMETRY PARAMETERS ----------------------------------------

Rotor geometry

rotor_file = "WindTurbine.csv" # Rotor geometry
data_path = uns.def_data_path # Path to rotor database
pitch = 0.0 # (deg) collective pitch of blades
CW = true # Clock-wise rotation
xfoil = false # Whether to run XFOIL
ncrit = 9 # Turbulence criterion for XFOIL

NOTE: If xfoil=true, XFOIL will be run to generate the airfoil polars used

by blade elements before starting the simulation. XFOIL is run

on the airfoil contours found in rotor_file at the corresponding

local Reynolds and Mach numbers along the blade.

Alternatively, the user can provide pre-computer airfoil polars using

xfoil=false and pointing to polar files through rotor_file.

Discretization

n = 40 # Number of blade elements per blade
r = 1/5 # Geometric expansion of elements

NOTE: Here a geometric expansion of 1/5 means that the spacing between the

tip elements is 1/5 of the spacing between the hub elements. Refine the

discretization towards the blade tip like this in order to better

resolve the tip vortex.

Read radius of this rotor and number of blades

R, B = uns.read_rotor(rotor_file; data_path=data_path)[[1,3]]

----------------- SIMULATION PARAMETERS --------------------------------------

Operating conditions

RPM = 1260/(2pi) # RPM
AOA = 0 # (deg) Angle of attack (incidence angle)
#J = 0.0455 # Advance ratio Vinf/(nD)
rho = 1.20 # (kg/m^3) air density
mu = 1.80882e-5 # (kg/ms) air dynamic viscosity
nu = mu/rho #(m^2/s) air kinematic viscosity
speedofsound = 343.2619 # (m/s) speed of sound

magVinf = 6
#magVinf =JRPM/60(2R)
Vinf(X, t) = magVinf[cosd(AOA), sind(AOA), 0] # (m/s) freestream velocity vector
J = magVinf/((RPM/60)2R) # Advance ratio Vinf/(nD)
ReD = 2piRPM/60R * rho/mu * 2R # Diameter-based Reynolds number
Matip = 2piRPM/60*R / speedofsound # Tip Mach number

println("""
RPM: $(RPM)
Vinf: $(Vinf(zeros(3), 0)) m/s
Matip: $(round(Matip, digits=3))
ReD: $(round(ReD, digits=0))
J: $(J)
""")

----------------- SOLVER PARAMETERS ------------------------------------------

Aerodynamic solver

VehicleType = uns.UVLMVehicle # Unsteady solver

VehicleType = uns.QVLMVehicle # Quasi-steady solver

const_solution = VehicleType==uns.QVLMVehicle # Whether to assume that the
# solution is constant or not

Time parameters

nrevs = 35 # Number of revolutions in simulation
nsteps_per_rev = 180 # Time steps per revolution
nsteps = const_solution ? 2 : nrevs*nsteps_per_rev # Number of time steps
ttot = nsteps/nsteps_per_rev / (RPM/60) # (s) total simulation time

VPM particle shedding

p_per_step = 3 # Sheds per time step
shed_starting = false # Whether to shed starting vortex
shed_unsteady = true # Whether to shed vorticity from unsteady loading
unsteady_shedcrit = 0.001 # Shed unsteady loading whenever circulation
# fluctuates by more than this ratio
wake_coupled =true
max_particles = ((2*n+1)*B)nstepsp_per_step + 1 # Maximum number of particles

Regularization

sigma_rotor_surf= R/80 # Rotor-on-VPM smoothing radius
lambda_vpm = 1.5 # VPM core overlap
# VPM smoothing radius
sigma_vpm_overwrite = lambda_vpm * 2piR/(nsteps_per_rev*p_per_step)
sigmafactor_vpmonvlm=5.5

Rotor solver

vlm_rlx = 0.7 # VLM relaxation <-- this also applied to rotors

vpm_integration = vpm.rungekutta3

#Corrections
hubtiploss_correction = vlm.hubtiploss_nocorrection # Hub and tip loss correction
Mach_correction = false
_3D_correction = false
AR_to_360extrap = false

VPM solver

#vpm_viscous = vpm.Inviscid() # VPM viscous diffusion scheme # VPM viscous diffusion scheme (vpm.Inviscid(), vpm.CoreSpreading(nu, sgm0, zeta), or vpm.ParticleStrengthExchange(nu))
vpm_viscous = vpm.CoreSpreading(nu, 0.01, vpm.zeta_fmm; beta=4, itmax=20, tol=1e-1)

vpm_SFS = vpm.SFS_none # VPM LES subfilter-scale model

vpm_SFS = vpm.SFS_Cd_twolevel_nobackscatter

vpm_SFS = vpm.SFS_Cd_threelevel_nobackscatter

#vpm_SFS = vpm.DynamicSFS(vpm.Estr_fmm, vpm.pseudo3level_positive;

alpha=0.999, maxC=1.0,

clippings=[vpm.clipping_backscatter])

vpm_SFS = vpm.DynamicSFS(vpm.Estr_fmm, vpm.pseudo3level_positive;
alpha=0.999, rlxf=0.01, minC=0, maxC=1,
clippings=[vpm.clipping_backscatter],

                             )

NOTE: In most practical situations, open rotors operate at a Reynolds number

high enough that viscous diffusion in the wake is actually negligible.

Hence, it does not make much of a difference whether we run the

simulation with viscous diffusion enabled or not. On the other hand,

such high Reynolds numbers mean that the wake quickly becomes turbulent

and it is crucial to use a subfilter-scale (SFS) model to accurately

capture the turbulent decay of the wake (turbulent diffusion).

if VehicleType == uns.QVLMVehicle
# NOTE: If the quasi-steady solver is used, this mutes warnings regarding
# potential colinear vortex filaments. This is needed since the
# quasi-steady solver will probe induced velocities at the lifting
# line of the blade
uns.vlm.VLMSolver._mute_warning(true)
end

############### Wake Fountain supression ##################

suppress_fountain = true # Toggle

Supress wake shedding on blade elements inboard of this r/R radial station

no_shedding_Rthreshold = suppress_fountain ? 0.35 : 0.0

Supress wake shedding for this many time steps

no_shedding_nstepsthreshold = 3*nsteps_per_rev

omit_shedding = [] # Index of blade elements to supress wake shedding

Function to suppress or activate wake shedding

function wake_treatment_supress(sim, args...; optargs...)

# Case: start of simulation -> suppress shedding
if sim.nt == 1

    # Identify blade elements on which to suppress shedding
    for i in 1:vlm.get_m(rotor)
        HS = vlm.getHorseshoe(rotor, i)
        CP = HS[5]

        if uns.vlm.norm(CP - vlm._get_O(rotor)) <= no_shedding_Rthreshold*R
            push!(omit_shedding, i)
        end
    end
end

# Case: sufficient time steps -> enable shedding
if sim.nt == no_shedding_nstepsthreshold

    # Flag to stop suppressing
    omit_shedding .= -1

end

return false

end

----------------- 1) VEHICLE DEFINITION --------------------------------------

println("Generating geometry...")

Generate rotor

rotor = uns.generate_rotor(rotor_file; pitch=pitch,
n=n, CW=CW, blade_r=r,
altReD=[RPM, J, mu/rho],
read_polar=vlm.ap.read_polar2,
xfoil=xfoil,
ncrit=ncrit,
data_path=data_path,
verbose=true,
verbose_xfoil=false,
plot_disc=true,

#custom
spline_k=5,
spline_s=0.0001,
turbine_flag=true,

rediscretize_airfoils=false,

                                    );

println("Generating vehicle...")

Generate vehicle

system = vlm.WingSystem() # System of all FLOWVLM objects
vlm.addwing(system, "Rotor", rotor)

rotors = [rotor]; # Defining this rotor as its own system
rotor_systems = (rotors, ); # All systems of rotors

wake_system = vlm.WingSystem() # System that will shed a VPM wake
# NOTE: Do NOT include rotor when using the quasi-steady solver
if VehicleType != uns.QVLMVehicle
vlm.addwing(wake_system, "Rotor", rotor)
end

vehicle = VehicleType( system;
rotor_systems=rotor_systems,
wake_system=wake_system
);

NOTE: Through the rotor_systems keyword argument to uns.VLMVehicle we

have declared any systems (groups) of rotors that share a common RPM.

We will later declare the control inputs to each rotor system when we

define the uns.KinematicManeuver.

------------- 2) MANEUVER DEFINITION -----------------------------------------

Non-dimensional translational velocity of vehicle over time

Vvehicle(t) = zeros(3)

Angle of the vehicle over time

anglevehicle(t) = zeros(3)

RPM control input over time (RPM over RPMref)

RPMcontrol(t) = 1.0

angles = () # Angle of each tilting system (none)
RPMs = (RPMcontrol, ) # RPM of each rotor system

maneuver = uns.KinematicManeuver(angles, RPMs, Vvehicle, anglevehicle)

NOTE: FLOWUnsteady.KinematicManeuver defines a maneuver with prescribed

kinematics. Vvehicle defines the velocity of the vehicle (a vector)

over time. anglevehicle defines the attitude of the vehicle over time.

angle defines the tilting angle of each tilting system over time.

RPM defines the RPM of each rotor system over time.

Each of these functions receives a nondimensional time t, which is the

simulation time normalized by the total time ttot, from 0 to

1, beginning to end of simulation. They all return a nondimensional

output that is then scaled by either a reference velocity (Vref) or

a reference RPM (RPMref). Defining the kinematics and controls of the

maneuver in this way allows the user to have more control over how fast

to perform the maneuver, since the total time, reference velocity and

RPM are then defined in the simulation parameters shown below.

------------- 3) SIMULATION DEFINITION ---------------------------------------

Vref = 0.0 # Reference velocity to scale maneuver by
RPMref = RPM # Reference RPM to scale maneuver by

Vinit = VrefVvehicle(0) # Initial vehicle velocity
Winit = pi/180(anglevehicle(1e-6) - anglevehicle(0))/(1e-6*ttot) # Initial angular velocity

simulation = uns.Simulation(vehicle, maneuver, Vref, RPMref, ttot;
Vinit=Vinit, Winit=Winit);
restart_file = nothing

------------- 4) MONITORS DEFINITIONS ----------------------------------------

figs, figaxs = [], [] # Figures generated by monitor

Generate rotor monitor

monitor_rotor = uns.generate_monitor_rotors(rotors, J, rho, RPM, nsteps;
t_scale=RPM/60, # Scaling factor for time in plots
t_lbl="Revolutions", # Label for time axis
out_figs=figs,
out_figaxs=figaxs,
save_path=save_path,
run_name=run_name,
figname="rotor monitor",

                                        )

monitor_enstrophy = uns.generate_monitor_enstrophy(;
save_path=save_path,
run_name=run_name,
figname="enstrophy monitor"
)

------------- 5) RUN SIMULATION ----------------------------------------------

println("Running simulation...")

Concatenate monitors and wake treatment procedure into one runtime function

runtime_function = uns.concatenate(monitor_rotor, wake_treatment_supress, monitor_enstrophy)

uns.run_simulation(simulation, nsteps;
# ----- SIMULATION OPTIONS -------------
Vinf=Vinf,
rho=rho, mu=mu, sound_spd=speedofsound,
# ----- SOLVERS OPTIONS ----------------
p_per_step=p_per_step,
max_particles=max_particles,
vpm_viscous=vpm_viscous,
vpm_SFS=vpm_SFS,
vpm_integration=vpm_integration,
sigma_vlm_surf=sigma_rotor_surf,
sigma_rotor_surf=sigma_rotor_surf,
sigma_vpm_overwrite=sigma_vpm_overwrite,
sigmafactor_vpmonvlm=sigmafactor_vpmonvlm,
vlm_rlx=vlm_rlx,
hubtiploss_correction=hubtiploss_correction,
Mach_correction=Mach_correction,
_3D_correction=_3D_correction,
AR_to_360extrap=AR_to_360extrap,
wake_coupled=wake_coupled,
shed_unsteady=shed_unsteady,
shed_starting=shed_starting,
omit_shedding=omit_shedding,
extra_runtime_function=runtime_function,
#--Restart---
restart_vpmfile=restart_file,
# ----- OUTPUT OPTIONS ------------------
save_path=save_path,
run_name=run_name,

	    verbose_nsteps  = 10,
	    save_horseshoes=true,
	    debug=true,
                );