computeFlappingPower: Calculate aerodynamic power flapping flight

Description Usage Arguments Details Value Note Author(s) References See Also Examples

View source: R/computeFlappingPower.R

Description

The function calculates the aerodynamic power required for the specified bird (or bat) at the specified flight speed.

Usage

1
computeFlappingPower(bird,speed,...,frequency,strokeplane)

Arguments

bird

object describing the relevant morphological parameters of the bird (or bat); this object should be created using the Bird constructor.

speed

a numeric vector of the airspeed.

...

optional arguments (see details)

frequency

wingbeat frequency as single numeric value, a numeric vector matching the speed vector, or a closure object describing the wingbeat frequency as a function of speed. If not provided, the function will look for a default wingbeat frequency in the bird object.

strokeplane

angle of the strokeplane in degrees, as a single numeric value, a numeric vector matching the speed vector, a closure object describing the strokeplane angle as a function of speed. Alternatively providing character string "opt" will tell the function to optimize the strokeplane angle for minimum aerodynamic power.

Details

This function estimates aerodynamic power for a animal in forward flight based on morphology and wingbeat kinematics (Klein Heerenbrink, 2015). The model takes into account span reduction during the upstroke, which is typical for vertebrate forward flight. ... The minimal input required for the function is a description of the animal (as provided by the Bird constructor) and the speed(range) for which to compute the aerodynamic power. Distinct from other models, this model also requires wingbeat frequency and strokeplane angle. Higher wingbeat frequency tends to lower the induced power, but it may increase profile power. If no wingbeat frequency is provided, the function will use the reference wingbeat frequency from the bird object. Otherwise the user can specify values (either as vectors or as closure object). The user can provide additional optional arguments:

bodyDragCoefficient

single numeric value, a numeric vector matching the speed vector, or a closure object as a function of speed. If not provided, the function will look for a default value in the bird object.

addedDrag

single numeric value or a numeric vector matching the speed vector. This represents additional "drag" (in Newtons) that must be overcome (e.g. during climb).

flightcondition

object describing the atmospheric conditions (density, viscosity, gravity).

Aerodynamic model

computeFlappingPower first computes the drag components for non-flapping flight:

D.ind = L^2 / (q * π * b^2)

D.pro0 = q * C.Dpro0 * S

D.pro2 = kp * L^2 / (q * S)

D.par = q * C.Dbody * S.b + D.added

which combine to the non-flapping thrust requirement T.0 = sum(D.<>). Here q = ρ * U^2 / 2 is the dynamic pressure depending on density (ρ) and speed (U). To account for how flapping the wings affects the drag on the wings, computeFlappingPower computes factors fD.ind, fD.pro0 and fD.pro2, which are functions of the strokeplane angle and the (reduced) wingbeat frequency. These factors relate to the returned drag factors kD.ind, kD.pro0 and kD.pro2 through

kD.<> = 1 + fD.<> * T/L

The actual drag in flapping flight is found by multiplying each non-flapping drag component with its respective drag factor. This means that the actual thrust requirement (thrust ratio T/L) can be computed as

T/L = T.0 / (L - fD.ind * D.ind - fD.pro0 * D.pro0 - fD.pro2 * D.pro2)

Finally, computeFlappingPower computes the power factors in a similar way to the drag factors (i.e. kP.i = 1 + fP.i * T/L, with fP.i functions of strokeplane angle and wingbeat frequency). The total aerodynamic power is then computed as

P = kP.ind * D.ind * U + kP.pro0 * D.pro0 * U + kP.pro2 * D.pro2 * U + D.par * U

Wingbeat optimization

The underlying numerical model that is represented by functions fD.i and fP.i, has optimised the flapping amplitude for minimum induced power. This means computeFlappingPower implicitly optimizes flapping amplitude, which is the value amplitude returned in the output.

computeFlappingPower takes strokeplane angle as input. The underlying numerical model has only explored strokeplane angles over a range of 0 (vertical) to 50 degrees, the latter being defined as having the down-stroke moving forward. In many cases it will be possible to find a strokeplane angle for which the total aerodynamic power is minimal. At high speeds this optimum will be for a vertical strokeplane while at lower speeds it will be more horizontal. By passing strokeplane="opt" as an argument to computeFlappingPower, it will try to numerically find the optimal strokeplane angle, using the function optimize.

Value

An object of class powercurve.mechanical, basically a data.frame including elements

speed

specified speed for which power is computed.

power

total aerodynamic power.

strokeplane

used strokeplane angle (either specified or optimized).

amplitude

wingbeat amplitude (implicitly optimized for minimum induced power).

frequency

wingbeat frequency (specified).

flags.redFreqLo

TRUE if reduced frequency too low (<1; outside model range).

flags.redFreqHi

TRUE if reduced frequency too high (>6; outside model range).

flags.thrustHi

TRUE if thrust requirement too high (>0.3; outside model range).

flags.speedLo

TRUE if speed is too low (invalidating the forward flight assumption).

kD.ind

induced drag factor

kD.pro0

zero lift profile drag factor

kD.pro2

lift dependent profile drag factor

kP.ind

induced power factor

kP.pro0

zero lift profile power factor

kP.pro2

lift dependent profile power factor

CDpro0

used zero lift profile drag coefficient (laminar boundary layer friction)

ReynoldsNumber

mean chord Reynolds number

Dnf.ind

non-flapping induced drag (N)

Dnf.pro0

non-flapping zero lift profile drag (N)

Dnf.pro2

non-flapping lift dependent profile drag (N)

Dnf.par

non-flapping parasitic drag (including body drag and apparent drag due to climbing)

L

lift (N)

Note

This model aims to predict the optimal flight performance for a bird. Particularly, the induced drag and induced power assume an ideal load distribution over the wing equivalent to the elliptical lift distribution for non-flapping wings. This means that induced power will typically be underestimated.

Author(s)

Marco Klein Heerenbrink

References

Klein Heerenbrink, M., Johansson, L. C. and Hedenström, A. (2015) Power of the wingbeat: modelling the effects of flapping wings in vertebrate flight. Proc. R. Soc. A 471, 2177 doi: 10.1098/rspa.2014.0952

See Also

Bird, amplitude, fD.ind, fD.pro0, fD.pro2, fP.ind, fP.pro0, fP.pro2

Examples

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
## Define a bird:
myBird = Bird(
  massTotal = 0.215, #  (kg) total body mass
  wingSpan = 0.67, #  (m) maximum wing span
  wingArea = 0.0652, #  (m2) maximum wing area
  type = "passerine"
)

## define a speed range
speedrange <- seq(5,14,length.out=5)

## compute aerodynamic power for that speed range:
Paero <- computeFlappingPower(myBird,speedrange)
print(Paero[c("speed","power","frequency","strokeplane")])
#   speed    power frequency strokeplane
# 1  5.00 2.789751  5.948083    46.56887
# 2  7.25 2.129466  5.948083    31.89129
# 3  9.50 2.203773  5.948083    22.51896
# 4 11.75 2.740763  5.948083    16.49120
# 5 14.00 3.673714  5.948083    12.09174

## prescribe strokeplane angle:
Paero <- computeFlappingPower(myBird,speedrange,strokeplane=20)
print(Paero[c("speed","power","frequency","strokeplane")])
#   speed    power frequency strokeplane
# 1  5.00 2.950259  5.948083          20
# 2  7.25 2.141581  5.948083          20
# 3  9.50 2.204132  5.948083          20
# 4 11.75 2.741335  5.948083          20
# 5 14.00 3.676224  5.948083          20

## prescribe frequency as a function of speed:
funFrequency = function(U){19.8 - 4.7*U + 0.45*U^2 - 0.0138*U^3}
Paero <- computeFlappingPower(myBird,speedrange,frequency=funFrequency,strokeplane='opt')
print(Paero[c("speed","power","frequency","strokeplane")])
#   speed    power frequency strokeplane
# 1  5.00 2.810431  5.825000    46.16223
# 2  7.25 2.356278  4.119247    25.99702
# 3  9.50 2.390251  3.930725    17.94304
# 4 11.75 2.860463  4.316291    14.52910
# 5 14.00 3.794431  4.332800    11.70058

## examine effect of frequency for a single airspeed:
speedrange <- rep(10,5) #  repeated speed
freqrange <- seq(3,10,length.out=5) #  frequency range
Paero <- computeFlappingPower(myBird,speedrange,frequency=freqrange,strokeplane='opt')
print(Paero[c("speed","power","frequency","strokeplane")])
#   speed    power frequency strokeplane
# 1    10 2.681028      3.00    13.87797
# 2    10 2.367982      4.75    18.90949
# 3    10 2.263765      6.50    21.52433
# 4    10 2.219739      8.25    21.71519
# 5    10 2.200852     10.00    20.18503

afpt documentation built on Sept. 2, 2017, 1:06 a.m.