Title: | Tools for Modelling of Animal Flight Performance |
---|---|
Description: | Allows estimation and modelling of flight costs in animal (vertebrate) flight, implementing the aerodynamic power model described in Klein Heerenbrink et al. (2015) <doi:10.1098/rspa.2014.0952>. Taking inspiration from the program 'Flight', developed by Colin Pennycuick (Pennycuick (2008) "Modelling the flying bird". Amsterdam: Elsevier. ISBN 0-19-857721-4), flight performance is estimated based on basic morphological measurements such as body mass, wingspan and wing area. 'afpt' can be used to make predictions on how animals should adjust their flight behaviour and wingbeat kinematics to varying flight conditions. |
Authors: | Marco KleinHeerenbrink [aut, cre]
|
Maintainer: | Marco KleinHeerenbrink <[email protected]> |
License: | GPL (>= 3) |
Version: | 1.1.0.4 |
Built: | 2025-02-18 05:57:11 UTC |
Source: | https://github.com/marcoklh/afpt-r |
Computes groundspeed from airspeed and wind.
air2ground(airSpeed, windSpeed = 0, windDir = 0, climbAngle = 0)
air2ground(airSpeed, windSpeed = 0, windDir = 0, climbAngle = 0)
airSpeed |
airspeed |
windSpeed |
windspeed |
windDir |
wind direction relative to (intended) track direction in degrees |
climbAngle |
climb angle in degrees |
driftAngle |
Angle between airspeed and groundspeed |
groundSpeed |
Speed over ground |
Marco Klein Heerenbrink
This function computes the air density at a specified altitude in the Troposphere of the International Standard Atmosphere.
altitude2density(altitude = 0)
altitude2density(altitude = 0)
altitude |
(geopotential) altitude in meters above sealevel. |
with
= 1.225 kg/m3,
= -0.0065 K/m,
geopotential altitude in meters,
= 9.80665 m/s2, and
= 287.1 J/Kg/K.
Numerical value or array for the density in kg/m3
M. Klein Heerenbrink
U.S. Standard Atmosphere, 1976, U.S. Government Printing Office, Washington, D.C.
altitude <- seq(0,3000,100) # meters above sealevel density <- altitude2density(altitude)
altitude <- seq(0,3000,100) # meters above sealevel density <- altitude2density(altitude)
This function returns the angular peak amplitude of the flapping motion, optimized for minimum induced power for prescribed reduced frequency (kf), strokeplane angle (phi), and thrust-to-lift ratio (TL).
amplitude(kf, phi, TL)
amplitude(kf, phi, TL)
Using for wingbeat frequency,
for wingspan, and
for air speed:
kf |
reduced frequency ( |
phi |
strokeplane angle in radians; valid range between 0 and 0.87 rad (50 deg) |
TL |
thrust requirement or the trust-to-lift ratio; valid range between 0 and 0.3 |
Angular peak amplitude of the flapping motion in degrees.
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
## reduced frequency kf <- 2*pi*4/10 # 4 Hz at 10 m/s for 1m wing span ## strokeplane angle phi <- 20*pi/180 # 20 degrees ## thrust ratio TL <- 0.2 ## wingbeat amplitude theta <- amplitude(kf,phi,TL) print(theta) # [1] 49.17679
## reduced frequency kf <- 2*pi*4/10 # 4 Hz at 10 m/s for 1m wing span ## strokeplane angle phi <- 20*pi/180 # 20 degrees ## thrust ratio TL <- 0.2 ## wingbeat amplitude theta <- amplitude(kf,phi,TL) print(theta) # [1] 49.17679
This function creates a bird description object, which is basically just a list with predefined variable names. It is named a bird object, but could also contain a description of a bat or insect. Minimal input required to construct a bird are body mass, wing span and wing area (or wing aspect ratio). Other required variables will then be given default values, or they will be estimated from allometric relations from literature.
Bird(massTotal, wingSpan, wingArea, ...)
Bird(massTotal, wingSpan, wingArea, ...)
massTotal |
Total mass that needs to be lifted in flight in kg |
wingSpan |
The maximum distance between the wingtips in meters |
wingArea |
The area of the fully stretched wings including the root area (left wing, right wing and area in between the wing roots) |
... |
Any other properties of a valid bird object (see details) |
This function sets up a list of properties of a bird. This definition of the bird is then used by the other functions in the package to estimate flight performance. At least three properties need to be specified: massTotal
, wingSpan
and wingArea
. Either wingSpan
or wingArea
could be replaced by aspectRatio
; the missing variable will then be computed. If no other properties are specified, default values will be used. Wingspan and wingarea should be measured from the maximally stretched out wing as described in Pennycuick (2008): wingspan as the maximum distance between the wingtips and wingarea as the area from a trace including the root area (where the body is).
To specify custom properties, these can simply be added as additional arguments to the function. Note that massTotal
needs to be the sum of massLoad
, massFat
and massEmpty
. The function will recompute the total mass if the specified masses are inconsistent. Allometric relations use the empty weight. Muscle mass is part of the empty mass, and as such it is represented by muscleMass
as a fraction. It is used in the estimation of the mechanical power available for flight (together with the muscle properties coef.activeStrain
and coef.isometricStress
). The variable type
is used for selected allometric relationships that are specific to that particular group. Currently, bodyFrontalArea
distinguishes between 'passerine'
and anything else and basalMetabolicRate
distinguishes between 'passerine'
, 'seabird'
, 'bat'
and anything else.
name |
String | Common name |
name.scientific |
Sring | Scientific name |
source |
String | Source for information |
massLoad |
Numeric | Additional mass the bird is carrying (kg); 0 |
massFat |
Numeric | Fat mass, i.e. fuel (kg); 0 |
massEmpty |
Numeric | Empty mass, i.e. total mass - fat mass - load mass (kg) |
muscleFraction |
Numeric | Fraction [0,1] of empty mass that makes up flight muscle; 0.17* |
type |
String | Type of bird 'other' *, 'passerine' *, 'seabird' , 'bat'
|
bodyFrontalArea |
Numeric | Reference body frontal area used for body drag (m2) |
wingbeatFrequency |
Numeric | Typical wingbeat frequency (Hz) |
coef.profileDragLiftFactor |
Numeric | Coefficient for lift dependent profile drag; 0.03 (Klein Heerenbrinkn et al. 2015) |
coef.bodyDragCoefficient |
Numeric | Drag coefficient related to body frontal area; 0.2** |
coef.conversionEfficiency |
Numeric | Efficiency Chemical to Mechanical energy; 0.23* |
coef.respirationFactor |
Numeric | Multiplyer for metabolic overhead respiration; 1.1* |
coef.activeStrain |
Numeric | Muscle duty cycle factor; 0.26* |
coef.isometricStress |
Numeric | Maximum force produced per cross section muscle (Pa); 400000 (upper limit from Pennycuick & Rezende 1984) |
basalMetabolicRate |
Numeric | Minimum energy consumption required for sustain life functions (W) *. |
* as in Flight 1.25 (Pennycuick 2008)
** Large body of data supporting higher body drag coefficients (>0.2) than in Flight 1.25 (0.1), e.g. Pennycuick et al. (1988), Hedenström & Liechti (2001), Henningsson & Hedenström (2011) and KleinHeerenbrink et al. (2016)
bird object with variables required by the various power estimating functions (e.g. computeFlappingPower
).
Marco Klein Heerenbrink
Hedenström, A. & Liechti, F. (2001) Field estimates of body drag coefficient on the basis of dives in passerine birds. J. Exp. Biol. 204, 1167–75.
Henningsson, P. & Hedenström, A. (2011) Aerodynamics of gliding flight in common swifts. J. Exp. Biol. 214, 382–93. doi:10.1242/jeb.050609
Klein Heerenbrink, M., Johansson, L. C. & Hedenström, A. (2015) Power of the wingbeat: modelling the effects of flapping wings in vertebrate flight. Proc. R. Soc. A 471. doi:10.1098/rspa.2014.0952
KleinHeerenbrink, M., Warfvinge, K. & Hedenström, A. (2016) Wake analysis of aerodynamic components for the glide envelope of a jackdaw (Corvus monedula). J. Exp. Biol. 219, 1572–1581. doi:10.1242/jeb.132480
Pennycuick, C. J. & Rezende, M. A. (1984) The specific power output of aerobic muscle, related to the power density of mitochondria. J. Exp. Biol., 108, 377–392.
Pennycuick, C. J., Obrecht III, H. H. & Fuller, M. R. (1988) Empirical estimates of body drag of large waterfowl and raptors. J. Exp. Biol. 135, 253–264.
Pennycuick, C. J. (2008). Modelling the flying bird. Amsterdam, The Netherlands: Elsevier.
computeAvailablePower
, computeChemicalPower
, computeFlappingPower
, computeBodyFrontalArea
, etc.
myBird = Bird( massTotal = 0.215, wingSpan = 0.67, wingArea = 0.0652, name = 'jackdaw', type = 'passerine' ) print(myBird)
myBird = Bird( massTotal = 0.215, wingSpan = 0.67, wingArea = 0.0652, name = 'jackdaw', type = 'passerine' ) print(myBird)
Data extracted from Hedenström & Alerstam 1992.
data("climbing_birds")
data("climbing_birds")
A data frame with 15 observations on the following 11 variables.
number
a numeric vector
name
a character vector
name.scientific
a character vector
massEmpty
a numeric vector
massFat
a numeric vector
wingSpan
a numeric vector
wingAspect
a numeric vector
wingbeatFrequency
a numeric vector
climbRate
a numeric vector
climbSpeed
a numeric vector
climbAlitude
a numeric vector
Hedenström A., Alerstam, T. (1992) Climbing performance of migrating birds as a basis for estimating limits for fuel-carrying capacity and muscle work. J. Exp. Biol 164 19-38 doi:10.1242/jeb.164.1.19
data(climbing_birds) climbingBirds <- Bird(climbing_birds)
data(climbing_birds) climbingBirds <- Bird(climbing_birds)
Estimation of maximum available power available from the muscles.
computeAvailablePower(bird, maxPowerAero, ...)
computeAvailablePower(bird, maxPowerAero, ...)
bird |
bird description object (see |
maxPowerAero |
maximum continuous power |
... |
optional arguments (none yet) |
Available power is determined as a muscle property. It is assumed that part of the muscles tissue is chemically active (mitochondria), providing the required ATP energy to the mechanically active tissue (myofibrils). The fraction of mitochondria determines the maximum sustainable power output from the muscles. With a higher fraction of myofibrils, the muscles can produce more power, but only in a short burst, until all ATP runs out.
If only a Bird
object is provided, the function will assume that maximum power equals maximum continuous power (maxPowerAero
). Otherwise, it will compute the burst maximum power.
numeric value of mechanical power
Available power is determined as a constant for the muscles. In reality the muscle power output depends on strainrate and stress, which in vertebrates are directly linked to wingbeat kinematics and aerodynamic loads.
Flight 1.25, the model of Pennycuick (2008) uses an isometric stress of 560 kN/m2. This is much higher than any measured value (Pennycuick & Rezende 1984). A more reasonable yet still very optimistic value would be 400 kn/m2, which is the default value assigned by the Bird
constructor.
Marco Klein Heerenbrink
Pennycuick, C. J. & Rezende, M. A. (1984) The specific power output of aerobic muscle, related to the power density of mitochondria. J. Exp. Biol., 108, 377–392.
Pennycuick, C. J. (2008). Modelling the flying bird. Amsterdam, The Netherlands: Elsevier.
## 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" ) ## for maximum continuous power power.max <- computeAvailablePower(myBird) print(power.max) # [1] 5.233528 ## for specified maximum continuous power: power.max.continuous <- 0.8*power.max power.max.burst <- computeAvailablePower(myBird,power.max.continuous) print(power.max.burst) # [1] 5.466625
## 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" ) ## for maximum continuous power power.max <- computeAvailablePower(myBird) print(power.max) # [1] 5.233528 ## for specified maximum continuous power: power.max.continuous <- 0.8*power.max power.max.burst <- computeAvailablePower(myBird,power.max.continuous) print(power.max.burst) # [1] 5.466625
Body frontal area is a parameter that relates to body drag. This function estimates body frontal area based on empirical scaling relations with mass.
computeBodyFrontalArea(massEmpty, type = "other")
computeBodyFrontalArea(massEmpty, type = "other")
massEmpty |
empty body mass (in kg) |
type |
type of bird; available options are: “passerine” and “other”) |
Passerine (Hedenström and Rosén 2003):
Other (Pennycuick et al. 1988):
Numeric value for the body frontal area.
Body frontal area is used for the computation of body drag. Only use this value if it matches the used definition of the body drag coefficient.
Marco Klein Heerenbrink
Pennycuick, C. J., Obrecht III, H. H. and Fuller, M. R. (1988) Empirical estimates of body drag of large waterfowl and raptors. J. Exp. Biol. 135, 253–264.
Hedenström, A. and Rosén, M. (2003) Body frontal area in passerine birds. J. Avian Biol. 34, 159–162.
massEmpty <- 0.215 # kg Sb <- computeBodyFrontalArea(massEmpty) print(Sb) # [1] 0.002920751 # m2 massEmpty <- 0.215 # kg birdType <- "passerine" # Sb <- computeBodyFrontalArea(massEmpty,birdType) print(Sb) # [1] 0.005020037 # m2
massEmpty <- 0.215 # kg Sb <- computeBodyFrontalArea(massEmpty) print(Sb) # [1] 0.002920751 # m2 massEmpty <- 0.215 # kg birdType <- "passerine" # Sb <- computeBodyFrontalArea(massEmpty,birdType) print(Sb) # [1] 0.005020037 # m2
Redundant after chemical power is now computed in all functions by default.
Computes the chemical power, i.e. the rate at which chemical energy is consumed, during flight. It takes into account the basal metabolic rate, and the energy needed by the flight muscles to provide the mechanical power required for flight.
## S3 method for class 'power.mechanical' computeChemicalPower(power.mech, bird, ...) ## S3 method for class 'numeric' computeChemicalPower(power.mech, bird, ...)
## S3 method for class 'power.mechanical' computeChemicalPower(power.mech, bird, ...) ## S3 method for class 'numeric' computeChemicalPower(power.mech, bird, ...)
power.mech |
mechanical power (either numeric (W) or as an mechanical power object (class power.mechanical) |
bird |
object describing the relevant morphological parameters of the bird (or bat); this object should be created using the |
... |
optional arguments (none yet) |
Chemical power is computed as
as described by Pennycuick (2008). Here is the respiration factor,
is the muscle conversion efficiency and
the basal metabolic rate, see
Bird
.
Chemical power of same type as inpute power.chem
.
Marco Klein Heerenbrink
Pennycuick, C. J. (2008). Modelling the flying bird. Amsterdam, The Netherlands: Elsevier.
Bird
, computeFlappingPower
, mech2chem
, chem2mech
## 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" ) ## for maximum continuous power power.max <- computeAvailablePower(myBird) print(power.max) # [1] 5.233528 ## convert to chemical power power.max.chem <- computeChemicalPower(power.max,myBird) print(power.max.chem) # [1] 27.28913
## 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" ) ## for maximum continuous power power.max <- computeAvailablePower(myBird) print(power.max) # [1] 5.233528 ## convert to chemical power power.max.chem <- computeChemicalPower(power.max,myBird) print(power.max.chem) # [1] 27.28913
The function calculates the aerodynamic power required for the specified bird (or bat) at the specified flight speed.
computeFlappingPower(bird,speed,...,frequency,strokeplane)
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, a closure object returning a numeric value as a function of speed, or the character string 'recompute'. The latter will recompute the default frequency for the current flight condition (density) and the current total mass of the bird (assuming the frequency in bird is the default wingbeat frequency). 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:
which combine to the non-flapping thrust requirement . Here
is the dynamic pressure depending on density (
) and speed (
).
To account for how flapping the wings affects the drag on the wings,
computeFlappingPower
computes factors ,
and
, 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
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 ) can be computed as
Finally, computeFlappingPower
computes the power factors in a similar way to the drag factors (i.e. , with
functions of strokeplane angle and wingbeat frequency).
The total aerodynamic power is then computed as
The underlying numerical model that is represented by functions and
, 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
.
A data.frame including elements
speed |
specified speed for which power is computed. |
power |
total aerodynamic power. |
power.chem |
total chemical 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
## 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
## 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
This function calculates the basic characteristic flight speeds for bird
.
computeFlightPerformance(bird, ..., length.out=10)
computeFlightPerformance(bird, ..., length.out=10)
bird |
description of the bird or bat, constructed using the |
... |
various optional arguments that are passed on to other functions; see details |
length.out |
length of calculated power curve; set |
Optional arguments can be provided through ...
. These can be arguments of computeFlappingPower
, e.g. strokeplane
, frequency
, etc., or arguments for findMaximumRangeSpeed
, e.g. windSpeed
and windDir
. The latter will only affect the outcome of the maximum range speed, and should perhaps not be analysed through the current function...
birdWSName |
variable name in work-space of the bird object |
bird |
bird object |
table |
table with characteristic speeds |
maxClimb |
table with climb performance |
powercurve |
power curve from minimum to maximum speed of length |
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
## Not run: # computationally intensive ## Define a bird: myBird = Bird( name = "Jackdaw", name.scientific = "Corvus monedula", massTotal = 0.215, # (kg) total body mass wingSpan = 0.67, # (m) maximum wing span wingArea = 0.0652, # (m2) maximum wing area type = "passerine" ) ## simplest performance calculation performance.myBird <- computeFlightPerformance(myBird) performance.myBird # Name: Jackdaw # Sc. name: Corvus monedula # Bird definitions: NA # speed power.aero power.chem strokeplane amplitude # minimumSpeed 2.706 5.234 27.29 49.9 51.3 # minimumPower 8.031 2.093 12.27 28.1 34.5 # maximumRange 11.025 2.523 14.33 18.2 36.7 # maximumSpeed 16.590 5.235 27.29 6.8 50.2 # Maximum climb performance: # speed power.aero power.chem strokeplane amplitude climbRate # maximumClimbRate 8.89 5.234 27.29 24.5 53.9 1.18 # Minimized migration time: # speed speed.migration power.aero power.chem power.dep strokeplane amplitude # minimumTimeSpeed 11.75 1.962 2.741 15.37 3.081 16.49 38.04 ## optimize strokeplane angle and use speed dependent frequency funFrequency = function(U){19.8 - 4.7*U + 0.45*U^2 - 0.0138*U^3} performance.myBird <- computeFlightPerformance(myBird,strokeplane='opt',frequency=funFrequency) performance.myBird # Name: Jackdaw # Sc. name: Corvus monedula # Bird definitions: NA # speed power.aero power.chem strokeplane amplitude # minimumSpeed 2.293 5.229 27.27 49.9 43.8 # minimumPower 8.192 2.319 13.35 21.6 42.8 # maximumRange 11.463 2.775 15.53 14.9 44.3 # maximumSpeed 16.088 5.233 27.29 8.3 64.5 # Maximum climb performance: # speed power.aero power.chem strokeplane amplitude climbRate # maximumClimbRate 8.89 5.234 27.29 24.5 53.9 1.18 # Minimized migration time: # speed speed.migration power.aero power.chem power.dep strokeplane amplitude # minimumTimeSpeed 12.07 1.905 2.964 16.43 3.081 14.13 45.13 ## plot variation of speed, power and flapping kinematics plot(performance.myBird$powercurve[c('speed','power.aero','strokeplane','frequency','amplitude')]) ## plot power factors plot(performance.myBird$powercurve[c('speed','power.aero')]) plot(performance.myBird$powercurve[c('speed','kP.ind')]) plot(performance.myBird$powercurve[c('speed','kP.pro0')]) plot(performance.myBird$powercurve[c('speed','kP.pro2')]) ## End(Not run) # end dontrun
## Not run: # computationally intensive ## Define a bird: myBird = Bird( name = "Jackdaw", name.scientific = "Corvus monedula", massTotal = 0.215, # (kg) total body mass wingSpan = 0.67, # (m) maximum wing span wingArea = 0.0652, # (m2) maximum wing area type = "passerine" ) ## simplest performance calculation performance.myBird <- computeFlightPerformance(myBird) performance.myBird # Name: Jackdaw # Sc. name: Corvus monedula # Bird definitions: NA # speed power.aero power.chem strokeplane amplitude # minimumSpeed 2.706 5.234 27.29 49.9 51.3 # minimumPower 8.031 2.093 12.27 28.1 34.5 # maximumRange 11.025 2.523 14.33 18.2 36.7 # maximumSpeed 16.590 5.235 27.29 6.8 50.2 # Maximum climb performance: # speed power.aero power.chem strokeplane amplitude climbRate # maximumClimbRate 8.89 5.234 27.29 24.5 53.9 1.18 # Minimized migration time: # speed speed.migration power.aero power.chem power.dep strokeplane amplitude # minimumTimeSpeed 11.75 1.962 2.741 15.37 3.081 16.49 38.04 ## optimize strokeplane angle and use speed dependent frequency funFrequency = function(U){19.8 - 4.7*U + 0.45*U^2 - 0.0138*U^3} performance.myBird <- computeFlightPerformance(myBird,strokeplane='opt',frequency=funFrequency) performance.myBird # Name: Jackdaw # Sc. name: Corvus monedula # Bird definitions: NA # speed power.aero power.chem strokeplane amplitude # minimumSpeed 2.293 5.229 27.27 49.9 43.8 # minimumPower 8.192 2.319 13.35 21.6 42.8 # maximumRange 11.463 2.775 15.53 14.9 44.3 # maximumSpeed 16.088 5.233 27.29 8.3 64.5 # Maximum climb performance: # speed power.aero power.chem strokeplane amplitude climbRate # maximumClimbRate 8.89 5.234 27.29 24.5 53.9 1.18 # Minimized migration time: # speed speed.migration power.aero power.chem power.dep strokeplane amplitude # minimumTimeSpeed 12.07 1.905 2.964 16.43 3.081 14.13 45.13 ## plot variation of speed, power and flapping kinematics plot(performance.myBird$powercurve[c('speed','power.aero','strokeplane','frequency','amplitude')]) ## plot power factors plot(performance.myBird$powercurve[c('speed','power.aero')]) plot(performance.myBird$powercurve[c('speed','kP.ind')]) plot(performance.myBird$powercurve[c('speed','kP.pro0')]) plot(performance.myBird$powercurve[c('speed','kP.pro2')]) ## End(Not run) # end dontrun
Computes the thrust requirement dependency factor for drag and power factors in flapping flight based on reduced frequency (kf
) and strokeplane angle (phi
).
fD.ind(kf, phi) fD.pro0(kf, phi) fD.pro2(kf, phi) fP.ind(kf, phi) fP.pro0(kf, phi) fP.pro2(kf, phi)
fD.ind(kf, phi) fD.pro0(kf, phi) fD.pro2(kf, phi) fP.ind(kf, phi) fP.pro0(kf, phi) fP.pro2(kf, phi)
Using for wingbeat frequency,
for wingspan, and
for air speed:
kf |
reduced frequency ( |
phi |
strokeplane angle in radians; valid range between 0 and 0.87 rad (50 deg) |
Flapping of the wings alters the drag components on the wing. A drag component in flapping flight can be related to the drag component in non-flapping flight as . The factor
depends on reduced frequency
, strokeplane angle
and the thrust-to-lift ratio
:
. Functions
fD.ind
,fD.pro0
and fD.pro2
compute for induced drag, zero lift profile drag and lift dependent profile drag, respectively.
Similarly, the flapping power components can be computed as: , again with
. Functions
fP.ind
,fP.pro0
and fP.pro2
compute for induced power, zero lift profile power and lift dependent profile power, respectively.
Numeric value
Thrust requirement is the sum of all drag components in flapping flight divided by the lift. This means the thrust requirement itself is a function of the values of .
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
## reduced frequency kf <- 2*pi*4/10 # 4 Hz at 10 m/s ## strokeplane angle phi <- 20*pi/180 # 20 degrees ## thrust ratio TL <- 0.2 ## induced drag factor: fDind <- fD.ind(kf,phi) kDind <- 1 + fDind*TL print(kDind) # [1] 1.623659 ## zero lift drag factor: fDpro0 <- fD.pro0(kf,phi) kDpro0 <- 1 + fDpro0*TL print(kDpro0) # [1] 1.014899 ## lift dependent profile drag factor: fDpro2 <- fD.pro2(kf,phi) kDpro2 <- 1 + fDpro2*TL print(kDpro2) # [1] 1.511107 ## induced power factor: fPind <- fP.ind(kf,phi) kPind <- 1 + fPind*TL print(kPind) # [1] 1.996891 ## zero lift power factor: fPpro0 <- fP.pro0(kf,phi) kPpro0 <- 1 + fPpro0*TL print(kPpro0) # [1] 1.076046 ## lift dependent profile power factor: fPpro2 <- fP.pro2(kf,phi) kPpro2 <- 1 + fPpro2*TL print(kPpro2) # [1] 1.811983
## reduced frequency kf <- 2*pi*4/10 # 4 Hz at 10 m/s ## strokeplane angle phi <- 20*pi/180 # 20 degrees ## thrust ratio TL <- 0.2 ## induced drag factor: fDind <- fD.ind(kf,phi) kDind <- 1 + fDind*TL print(kDind) # [1] 1.623659 ## zero lift drag factor: fDpro0 <- fD.pro0(kf,phi) kDpro0 <- 1 + fDpro0*TL print(kDpro0) # [1] 1.014899 ## lift dependent profile drag factor: fDpro2 <- fD.pro2(kf,phi) kDpro2 <- 1 + fDpro2*TL print(kDpro2) # [1] 1.511107 ## induced power factor: fPind <- fP.ind(kf,phi) kPind <- 1 + fPind*TL print(kPind) # [1] 1.996891 ## zero lift power factor: fPpro0 <- fP.pro0(kf,phi) kPpro0 <- 1 + fPpro0*TL print(kPpro0) # [1] 1.076046 ## lift dependent profile power factor: fPpro2 <- fP.pro2(kf,phi) kPpro2 <- 1 + fPpro2*TL print(kPpro2) # [1] 1.811983
Numerically find the maximum attainable climb rate.
findMaximumClimbRate(bird, maximumPower, speed, ...)
findMaximumClimbRate(bird, maximumPower, speed, ...)
bird |
bird description object (see |
maximumPower |
numeric value for maximum available mechanical power |
speed |
airspeed for which to compute the maximum climbrate |
... |
optional arguments for |
The function searches for a climb angle between -90 and 90 degrees that matches the specified maximum power available. If no speed
provided, the function will also find the optimal airspeed for maximum climbrate.
Data frame of class power.mechanical
speed |
airspeed either prescribed or optimized for maximum climbrate |
power |
aerodynamic (mechanical) power matching maximum power |
... |
see |
climbAngle |
angle between flightpath and horizontal plane in degrees |
climbRate |
rate of vertical climb |
The function uses climb angle, rather than climb rate, in the search algorithm, to ensure that climb rate is always less than the airspeed (i.e. in a vertical climb the climb rate will simply equal airspeed). The actual climb rate is maximized by maximizing the product of climb angle and airspeed. However, in practice, the airspeed for best climb rate will be close to the minimum power airspeed, where the power margin is largest.
Marco Klein Heerenbrink
## 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" ) ## maximum power available: Paero.available <- computeAvailablePower(myBird) climbSpeed <- 8 # airspeed during climb ## find maximum climbrate: Paero.climb <- findMaximumClimbRate(myBird,Paero.available,climbSpeed) print(Paero.climb[c('speed','amplitude','frequency','climbRate')]) # speed amplitude frequency climbRate # 1 8 54.84965 5.948083 1.162002
## 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" ) ## maximum power available: Paero.available <- computeAvailablePower(myBird) climbSpeed <- 8 # airspeed during climb ## find maximum climbrate: Paero.climb <- findMaximumClimbRate(myBird,Paero.available,climbSpeed) print(Paero.climb[c('speed','amplitude','frequency','climbRate')]) # speed amplitude frequency climbRate # 1 8 54.84965 5.948083 1.162002
Numerically find the airspeed for which required power equals maximumPower
.
findMaximumPowerSpeed(bird, maximumPower, lower, upper, ...)
findMaximumPowerSpeed(bird, maximumPower, lower, upper, ...)
bird |
bird description object (see |
maximumPower |
numeric value for maximum available mechanical power |
lower |
lower bound for search range airspeed (m/s) |
upper |
upper bound for search range airspeed (m/s) |
... |
optional arguments to |
Prepares arguments for a call to uniroot
. The function searches for an airspeed between lower
and upper
that matches the specified maximum power available.
Data frame
speed |
airspeed for which power matches maximum power |
power |
aerodynamic (mechanical) power matching maximum power |
power.chem |
aerodynamic (mechanical) power matching maximum power |
strokeplane |
optimized or prescribed strokeplane angle in degrees (from vertical) |
amplitude |
optimized peak amplitude in degrees (see |
... |
see |
Typically this function would be used to find the maximum speed, but may in some cases also be used for the minimum flight speed. However, note that the low speed limit is likely limited by other constraints as well (e.g. stall speed).
Marco Klein Heerenbrink
## 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" ) Paero.available <- computeAvailablePower(myBird) ## find maximum speed: Vmin <- 5 Vmax <- 30 Paero.maxSpeed <- findMaximumPowerSpeed(myBird,Paero.available,Vmin,Vmax) print(Paero.maxSpeed[c('speed','power','amplitude','strokeplane','frequency')]) # speed power amplitude strokeplane frequency # 1 16.58797 5.233459 50.22762 6.812345 5.948083
## 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" ) Paero.available <- computeAvailablePower(myBird) ## find maximum speed: Vmin <- 5 Vmax <- 30 Paero.maxSpeed <- findMaximumPowerSpeed(myBird,Paero.available,Vmin,Vmax) print(Paero.maxSpeed[c('speed','power','amplitude','strokeplane','frequency')]) # speed power amplitude strokeplane frequency # 1 16.58797 5.233459 50.22762 6.812345 5.948083
This function performs a numerical optimization to find the airspeed for which is minimum. For this it uses the function
optimize
.
findMaximumRangeSpeed(bird,lower=NULL,upper=NULL,windSpeed=0,windDir=0,...)
findMaximumRangeSpeed(bird,lower=NULL,upper=NULL,windSpeed=0,windDir=0,...)
bird |
bird description object (see |
lower |
lower speed limit (optional) |
upper |
upper speed limit (optional) |
windSpeed |
wind magnitude (in m/s; optional) |
windDir |
wind direction (in degrees; optional) |
... |
optional arguments: |
This function performs a numerical optimization to find the airspeed for which is minimum. For this it uses the function
optimize
. This airspeed is searched for between lower
and upper
(if not provided, it will make a guess based on bird
). Flying in wind changes the ground speed, and therefore the optimum flight speed for maximum range. This can be taken into account through the optional arguments for wind magnitude (windSpeed
in m/s) and wind direction relative to the track direction (windDir
in degrees; windDir = 0
tail wind); see e.g. Liechti et al. 1994.
Returns data.frame (power.chemical) of flight performance at maximum range speed for bird
.
Marco Klein Heerenbrink
Liechti, F., Hedenström, A. and Alerstam, T. (1994). Effects of Sidewinds on Optimal Flight Speed of Birds. J. Theor. Biol. 170, 219–225.
computeChemicalPower
, computeFlappingPower
## 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" ) maximumRangeSpeed.chem <- findMaximumRangeSpeed(myBird) maximumRangeSpeed.chem[c('speed','power','strokeplane','amplitude','frequency')] # speed power strokeplane amplitude frequency # 1 11.02543 14.32754 18.17729 36.69311 5.948083 maximumRangeSpeed.chem.wind <- findMaximumRangeSpeed( myBird, windSpeed = 5, windDir = 90 ) maximumRangeSpeed.chem.wind[c('speed','power','strokeplane','amplitude','frequency')] # speed power strokeplane amplitude frequency # 1 11.81974 15.47758 16.33727 38.17508 5.948083
## 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" ) maximumRangeSpeed.chem <- findMaximumRangeSpeed(myBird) maximumRangeSpeed.chem[c('speed','power','strokeplane','amplitude','frequency')] # speed power strokeplane amplitude frequency # 1 11.02543 14.32754 18.17729 36.69311 5.948083 maximumRangeSpeed.chem.wind <- findMaximumRangeSpeed( myBird, windSpeed = 5, windDir = 90 ) maximumRangeSpeed.chem.wind[c('speed','power','strokeplane','amplitude','frequency')] # speed power strokeplane amplitude frequency # 1 11.81974 15.47758 16.33727 38.17508 5.948083
.
findMinimumPowerSpeed(bird, lower, upper, ...)
findMinimumPowerSpeed(bird, lower, upper, ...)
bird |
bird description object (see |
lower |
lower speed limit (optional) |
upper |
upper speed limit (optional) |
... |
optional arguments for |
This is pretty much just a call to optimize
.
powercurve object (funCalcPower
evaluated for the minimum speed)
Marco Klein Heerenbink
## 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" ) minimumPowerSpeed.aero <- findMinimumPowerSpeed(myBird) minimumPowerSpeed.aero[c('speed','power','strokeplane','amplitude','frequency')] # speed power strokeplane amplitude frequency # 1 8.030022 2.092976 28.14514 34.52719 5.948083
## 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" ) minimumPowerSpeed.aero <- findMinimumPowerSpeed(myBird) minimumPowerSpeed.aero[c('speed','power','strokeplane','amplitude','frequency')] # speed power strokeplane amplitude frequency # 1 8.030022 2.092976 28.14514 34.52719 5.948083
This function performs a numerical optimization to find the airspeed for which is minimum..
findMinimumTimeSpeed(bird, EnergyDepositionRate=1.5*bird$basalMetabolicRate, lower=NULL,upper=NULL, windSpeed=0,windDir=0,...)
findMinimumTimeSpeed(bird, EnergyDepositionRate=1.5*bird$basalMetabolicRate, lower=NULL,upper=NULL, windSpeed=0,windDir=0,...)
bird |
bird description object (see |
EnergyDepositionRate |
The rate at which the bird accumulates energy at stopover sites |
lower |
lower speed limit (optional) |
upper |
upper speed limit (optional) |
windSpeed |
wind magnitude (in m/s; optional) |
windDir |
wind direction (in degrees; optional) |
... |
optional arguments: |
This function performs a numerical optimization to find the airspeed that minimizes the combination of flight time and time required to (re)gain the energy reserves to cover the flight cost. If the bird would fly faster, it would need to spend more time refueling. If it flew slower, the reduced refueling time that comes with the lower cost of transport does not offset the longer flight time. Mathematically this problem works out as minimizing Hedenström 1998, which is technically the same optimization as for the maximum range speed (see details
findMaximumRangeSpeed
). The default energy deposition rate, the rate at which a bird accumulates energy during a stopover, is set to 1.5 times the basal metabolic rate (Lindström 1991).
Returns data.frame (power.chemical) of flight performance at maximum range speed for bird
.
Marco Klein Heerenbrink
Lindström, Å. (1991) Maximum fat deposition rates in migrating birds. Ornis Scand. 22, 12-19 (doi:10.2307/3676616)
Hedenström, A. & Alerstam, T. (1997) Optimum fuel loads in migratory birds: distinguishing between time and energy minimization. J. Theor. Biol. 189, 227–34. (doi:10.1006/jtbi.1997.0505)
Hedenström, A. & Alerstam, T. (1998) How fast can birds migrate? J. Avian Biol. 29, 424-432. (doi:10.2307/3677161)
computeChemicalPower
, computeFlappingPower
## 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" ) minimumTimeSpeed <- findMinimumTimeSpeed(myBird,1.5*myBird$basalMetabolicRate) minimumTimeSpeed[c('speed','speed.migration', 'power','power.chem','power.dep', 'strokeplane','amplitude','frequency')] # speed speed.migration power power.chem power.dep strokeplane amplitude frequency # 11.74944 1.962213 2.74058 15.36634 3.080752 16.49244 38.03366 5.948083
## 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" ) minimumTimeSpeed <- findMinimumTimeSpeed(myBird,1.5*myBird$basalMetabolicRate) minimumTimeSpeed[c('speed','speed.migration', 'power','power.chem','power.dep', 'strokeplane','amplitude','frequency')] # speed speed.migration power power.chem power.dep strokeplane amplitude frequency # 11.74944 1.962213 2.74058 15.36634 3.080752 16.49244 38.03366 5.948083
Functions convert between mechanical and chemical power
mech2chem(power.mech,bird,...) chem2mech(power.chem,bird,...)
mech2chem(power.mech,bird,...) chem2mech(power.chem,bird,...)
power.mech |
Numerical value for mechanical power |
power.chem |
Numerical value for chemical power |
bird |
object describing the relevant morphological parameters of the bird (or bat); this object should be created using the |
... |
optional arguments (none yet) |
Chemical power is computed as
as described in Pennycuick 2008. Here is the respiration factor,
is the muscle conversion efficiency and
the basal metabolic rate, see
Bird
.
Mechanical power is simply calculated inversely:
Numerical value of either chemical power (mech2chem()
) or mechanical power (chem2mech()
).
Marco Klein Heerenbrink
Pennycuick, C. J. (2008). Modelling the flying bird. Amsterdam, The Netherlands: Elsevier.
## 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) Pchem <- Paero Pchem$power <- mech2chem(Paero$power,myBird) print(Pchem[c("speed","power","frequency","strokeplane")]) # speed power frequency strokeplane # 1 5.00 15.60151 5.948083 46.56887 # 2 7.25 12.44362 5.948083 31.89129 # 3 9.50 12.79900 5.948083 22.51896 # 4 11.75 15.36721 5.948083 16.49120 # 5 14.00 19.82915 5.948083 12.09174 Pmech <- Pchem Pmech$power <- chem2mech(Pchem$power,myBird) print(Pmech[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
## 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) Pchem <- Paero Pchem$power <- mech2chem(Paero$power,myBird) print(Pchem[c("speed","power","frequency","strokeplane")]) # speed power frequency strokeplane # 1 5.00 15.60151 5.948083 46.56887 # 2 7.25 12.44362 5.948083 31.89129 # 3 9.50 12.79900 5.948083 22.51896 # 4 11.75 15.36721 5.948083 16.49120 # 5 14.00 19.82915 5.948083 12.09174 Pmech <- Pchem Pmech$power <- chem2mech(Pchem$power,myBird) print(Pmech[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
This function computes the reduced frequency based on wingSpan
(), wingbeat
frequency
() and
speed
():
.
reducedFrequency(wingSpan, frequency, speed)
reducedFrequency(wingSpan, frequency, speed)
wingSpan |
Tip-to-tip distance of the fully spread wing (m) |
frequency |
Wingbeat frequency (1/s) |
speed |
Airspeed (m/s) |
This parameter is the ratio of the wingspan to the wavelength of the convected wake. For very high reduced frequencies, the wake of one wingbeat is relatively short compared to the wingspan, meaning that previous wingbeats have a large influence on the aerodynamics of the current wingbeat. When the reduced frequency is low, there is relatively little interaction between the wingbeats.
This wingspan based reduced frequency should not be confused with the chord based (or half chord) based reduced frequency. That definition serves a similar function, however, it relates to the effect of unsteadyness on the aerofoil (i.e. it is somewhat like the 2D equivalent).
Another related parameter of unsteadyness, often mentioned in relation to animal flight, is the Strouhal number, representing the ratio of the amplitude of the wingbeat to the wavelength of the wake. This term is historically related to vortex shedding.
Numeric value
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
kf <- reducedFrequency( wingSpan = 0.67, frequency = 4, speed = 9 ) kf # [1] 1.870993
kf <- reducedFrequency( wingSpan = 0.67, frequency = 4, speed = 9 ) kf # [1] 1.870993