set_depower_steering!(s::AKM, depower, steering)

Setter for the depower and steering model inputs.

Parameters:

• depower: Relative depower, must be between 0 .. 1.0
• steering: Relative steering, must be between -1.0 .. 1.0.

This function sets the variables s.depower, s.steering and s.alpha_depower.

It takes the depower offset c0 and the dependency of the steering sensitivity from the depower settings into account.

set_v_wind_ground!(s::AKM, height, v_wind_gnd=s.set.v_wind; upwind_dir=0.0)

Set the vector of the wind-velocity at the height of the kite. As parameter the height, the ground wind speed [m/s] and the upwind direction [radians] are needed. Is called by the function next_step!.

unstretched_length(s::KPS4_3L)

Getter for the unstretched tether reel-out lenght (at zero force).

unstretched_length(s::AKM)

Getter for the unstretched tether reel-out lenght (at zero force).

tether_length(s::KPS4_3L)

Calculate and return the real, stretched tether lenght.

tether_length(s::AKM)

Calculate and return the real, stretched tether lenght.

pos_kite(s::KPS4)

Return the position of the kite (top particle).

pos_kite(s::KPS4_3L)

Return the position of the kite (top particle).

pos_kite(s::KPS3)

Return the position of the kite (top particle).

calc_height(s::KPS4)

Determine the height of the topmost kite particle above ground.

calc_height(s::KPS4_3L)

Determine the height of the topmost kite particle above ground.

calc_height(s::KPS3)

Determine the height of the kite particle above ground.

calc_elevation(s::AKM)

Determine the elevation angle of the kite in radian.

calc_azimuth(s::AKM)

Determine the azimuth angle of the kite in wind reference frame in radian. Positive anti-clockwise when seen from above.

calc_azimuth_east(s::AKM)

Determine the azimuth_east angle of the kite in radian. Positive clockwise when seen from above.

calc_azimuth_north(s::AKM)

Determine the azimuth_north angle of the kite in radian. Positive anti-clockwise when seen from above.

calc_heading(s::AKM; upwind_dir_=upwind_dir(s), neg_azimuth=false, one_point=false)

Determine the heading angle of the kite in radian.

calc_course(s::AKM)

Determine the course angle of the kite in radian. Undefined if the velocity of the kite is near zero.

cl_cd(s::KPS4)

Calculate the lift and drag coefficients of the kite, based on the current angles of attack.

cl_cd(s::KPS3)

Calculate the lift and drag coefficients of the kite, based on the current angles of attack.

winch_force(s::KPS4)

Return the absolute value of the force at the winch as calculated during the last timestep.

winch_force(s::KPS4_3L)

Return the absolute value of the force at the winch as calculated during the last timestep.

winch_force(s::KPS3)

Return the absolute value of the force at the winch as calculated during the last timestep.

spring_forces(s::AKM)

Return an array of the scalar spring forces of all tether segements.

lift_drag(s::AKM)

Return a tuple of the scalar lift and drag forces.

Example:

lift, drag = lift_drag(s)

lift_over_drag(s::AKM)

Return the lift-over-drag ratio.

v_wind_kite(s::AKM)

Return the vector of the wind speed at the height of the kite.

kite_ref_frame(s::KPS4; one_point=false)

Returns a tuple of the x, y, and z vectors of the kite reference frame.

kite_ref_frame(s::KPS4_3L; one_point=false)

Returns a tuple of the x, y, and z vectors of the kite reference frame. The parameter one_point is not used in this model.

kite_ref_frame(s::KPS3)

Returns a tuple of the x, y, and z vectors of the kite reference frame.

orient_euler(s::AKM)

Calculate and return the orientation of the kite in euler angles (roll, pitch, yaw) as SVector.

SysState(s::AKM, zoom=1.0)

Constructor for creating a SysState object from a kite model (KPS3 or KPS4). The SysState object can be used either for logging or for displaying the system state in a viewer. Optionally the position arrays can be zoomed according to the requirements of the viewer.

init_sim!(s::KPS4_3L; damping_coeff=50.0, prn=false, torque_control=true)

Initialises the integrator of the model.

Parameters:

• s: an instance of a 3 line kite model
• damping_coeff: amount of damping in the first steps
• prn: if set to true, print the detailed solver results
• torque_control: wether or not to use torque control

Returns: Nothing.

init_sim!(s::AKM; t_end=1.0, stiffness_factor=0.5, delta=0.001, upwind_dir=-pi/2, prn=false)

Initialises the integrator of the model.

Parameters:

• s: an instance of an abstract kite model
• t_end: end time of the simulation; normally not needed
• stiffness_factor: factor applied to the tether stiffness during initialisation
• delta: initial stretch of the tether during the steady state calculation
• upwind_dir: upwind direction in radians, the direction the wind is coming from. Zero is at north; clockwise positive. Default: -pi/2, wind from west.
• prn: if set to true, print the detailed solver results

Returns: An instance of a DAE integrator.

next_step!(s::AKM, integrator; set_speed = nothing, set_torque=nothing, set_force=nothing, bearing = nothing
           attractor=nothing, v_wind_gnd=s.set.v_wind, upwind_dir=-pi/2, dt=1/s.set.sample_freq)

Calculates the next simulation step. Either set_speed or set_torque must be provided.

Parameters:

• s: an instance of an abstract kite model
• integrator: an integrator instance as returned by the function init_sim!
• set_speed: set value of reel out speed in m/s or nothing
• set_torque: set value of the torque in Nm or nothing
• set_force: set value of the force in N or nothing (only for logging, not used otherwise)
• bearing: set value of heading/ course in radian or nothing (only for logging, not used otherwise)
• attractor: the attractor coordinates [azimuth, elevation] in radian or nothing (only for logging)
• v_wind_gnd: wind speed at reference height in m/s
• upwind_dir: upwind direction in radians, the direction the wind is coming from. Zero is at north; clockwise positive. Default: -pi/2, wind from west.
• dt: time step in seconds

Returns: The end time of the time step in seconds.

clear!(s::KPS4)

Initialize the kite power model.

clear!(s::KPS4_3L)

Initialize the kite power model.

clear!(s::KPS3)

Initialize the kite power model.

find_steady_state!(s::KPS4; prn=false, delta = 0.01, stiffness_factor=0.035, upwind_dir=-pi/2))

Find an initial equilibrium, based on the initial parameters l_tether, elevation and v_reel_out.

find_steady_state!(s::KPS3; prn=false, delta = 0.0, stiffness_factor=0.035, upwind_dir=-pi/2)

Find an initial equilibrium, based on the initial parameters l_tether, elevation and v_reel_out.

residual!(res, yd, y::MVector{S, SimFloat}, s::KPS4, time) where S

N-point tether model, four points for the kite on top:
Inputs:
State vector y   = pos1,  pos2, ... , posn,  vel1,  vel2, . .., veln,  length, v_reel_out
Derivative   yd  = posd1, posd2, ..., posdn, veld1, veld2, ..., veldn, lengthd, v_reel_outd
Output:
Residual     res = res1, res2 = vel1-posd1,  ..., veld1-acc1, ..., 

Additional parameters:
s: Struct with work variables, type KPS4
S: The dimension of the state vector

The number of the point masses of the model N = S/6, the state of each point is represented by two 3 element vectors.

residual!(res, yd, y::MVector{S, SimFloat}, s::KPS3, time) where S

N-point tether model, one point kite at the top:
Inputs:
State vector y   = pos1, pos2, ..., posn, vel1, vel2, ..., veln
Derivative   yd  = vel1, vel2, ..., veln, acc1, acc2, ..., accn
Output:
Residual     res = res1, res2 = pos1,  ..., vel1, ...

Additional parameters:
s: Struct with work variables, type KPS3
S: The dimension of the state vector

The number of the point masses of the model N = S/6, the state of each point is represented by two 3 element vectors.

copy_examples()

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

copy_bin()

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

calc_drag(s::KPS3, v_segment, unit_vector, rho, last_tether_drag, v_app_perp)

Calculate the drag of one tether segment, result stored in parameter last_tether_drag. Return the norm of the apparent wind velocity.

calc_set_cl_cd!(s::KPS3, vec_c, v_app)

Calculate the lift over drag ratio as a function of the direction vector of the last tether segment, the current depower setting and the apparent wind speed. Set the calculated CL and CD values in the struct s.

calc_aero_forces!(s::KPS4, pos, vel, rho, alpha_depower, rel_steering)

Calculates the aerodynamic forces acting on the kite particles.

Parameters:

• pos: vector of the particle positions
• vel: vector of the particle velocities
• rho: air density [kg/m^3]
• rel_depower: value between 0.0 and 1.0
• alpha_depower: depower angle [degrees]
• rel_steering: value between -1.0 and +1.0

Updates the vector s.forces of the first parameter.

calc_aero_forces!(s::KPS4_3L, eqs2, force_eqs, force, pos, vel, t, e_x, e_y, e_z, rho)

Calculates the aerodynamic forces acting on the kite particles.

Parameters:

• pos: vector of the particle positions
• vel: vector of the particle velocities
• rho: air density [kg/m^3]

Updates the vector s.forces of the first parameter.

calc_particle_forces!(s::KPS4, pos1, pos2, vel1, vel2, spring, segments, d_tether, rho, i)

Calculate the drag force of the tether segment, defined by the parameters pos1, pos2, vel1 and vel2 and distribute it equally on the two particles, that are attached to the segment. The result is stored in the array s.forces.

calc_particle_forces!(s::KPS4_3L, eqs2, force_eqs, force, pos1, pos2, vel1, vel2, length, c_spring, damping, 
                      rho, i, l_0, k, c, segment, rel_vel, av_vel, norm1, unit_vector, k1, k2, c1, spring_vel,
                      spring_force, v_apparent, v_wind_tether, area, v_app_perp, half_drag_force)

Calculate the drag force and spring force of the tether segment, defined by the parameters pos1, pos2, vel1 and vel2 and distribute it equally on the two particles, that are attached to the segment. The result is stored in the array s.forces.

inner_loop!(s::KPS4, pos, vel, v_wind_gnd, segments, d_tether)

Calculate the forces, acting on all particles.

Output:

• s.forces
• s.v_wind_tether

inner_loop!(s::KPS4_3L, eqs2, force_eqs, t, force, pos, vel, length, c_spring, damping, v_wind_gnd)

Calculate the forces, acting on all particles.

Output:length

• s.forces
• s.vwindtether

loop!(s::KPS4, pos, vel, posd, veld)

Calculate the vectors s.res1 and calculate s.res2 using loops that iterate over all tether segments.