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

View source: R/computeFlappingPower.R

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

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

`bird` |
object describing the relevant morphological parameters of the bird (or bat); this object should be created using the |

`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. |

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).

`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*

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`

.

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) |

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.

Marco Klein Heerenbrink

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

`Bird`

, `amplitude`

, `fD.ind`

, `fD.pro0`

, `fD.pro2`

, `fP.ind`

, `fP.pro0`

, `fP.pro2`

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.

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.