API Reference

Supertype for an object that recieves a noise prediction when combined with an acoustic analogy source; computational equivalent of a microphone.

(obs::AbstractAcousticObserver)(t)

Calculate the position of the acoustic observer at time t.

CombinedNoTipBroadbandSourceElement(rotor::CCBlade.Rotor, section::CCBlade.Section, op::CCBlade.OperatingPoint, out::CCBlade.Outputs, θ, Δr, h, Psi, τ, Δτ, bl::AbstractBoundaryLayer, positive_x_rotation)

Construct a source element for predicting turbulent boundary layer-trailing edge (TBLTE), laminar boundary layer-vortex shedding (LBLVS) noise, and trailing edge bluntness-vortex shedding (TEBVS) noise using the BPM/Brooks and Burley method from CCBlade structs.

The source element's position is calculated from section.r, rotor.precone, and the θ argument using

    sθ, cθ = sincos(θ)
    spc, cpc = sincos(precone)
    y0dot = [r*spc, r*cpc*cθ, r*cpc*sθ]

where y0dot is the position of the source element.

Arguments

• rotor::CCBlade.Rotor: CCBlade rotor object, needed for the precone angle.
• section::CCBlade.Section: CCBlade section object, needed for the radial location and chord length of the element.
• op::CCBlade.OperatingPoint: CCBlade operating point, needed for atmospheric properties.
• out::CCBlade.Outputs: CCBlade outputs object, needed for the loading.
• θ: polar coordinate of the element, in radians.
• Δr: length of the element, in meters.
• h: trailing edge thickness (m)
• Psi: solid angle between the blade surfaces immediately upstream of the trailing edge (rad)
• τ: source time of the element, in seconds.
• Δτ: source time duration, in seconds.
• bl: AcousticAnalogies.AbstractBoundaryLayer, needed for boundary layer properties.
• positive_x_rotation: rotate blade around the positive-x axis if true, negative-x axis otherwise.

CombinedNoTipBroadbandSourceElement(c0, nu, r, θ, Δr, chord, ϕ, h, Psi, U, α, τ, Δτ, bl, twist_about_positive_y)

Construct a source element for predicting turbulent boundary layer-trailing edge (TBLTE), laminar boundary layer-vortex shedding (LBLVS) noise, and trailing edge bluntness-vortex shedding (TEBVS) noise using the BPM/Brooks and Burley method, using the velocity magnitude U and angle of attack α.

The r and θ arguments are used to define the radial and circumferential position of the source element in a cylindrical coordinate system. The U and α arguments are the velocity magnitude normal to the source element length and the angle of attack, respectively. The cylindrical coordinate system is defined as follows:

• The normal/axial direction is in the positive x axis
• The circumferential/azimuth angle θ is defined such that θ = 0 means the radial direction is aligned with the positive y axis, and a positive θ indicates a right-handed rotation around the positive x axis.

The twist_about_positive_y is a Bool controling how the ϕ argument is handled, which in turn controls the orientation of a unit vector defining chord_uvec indicating the orientation of the chord line, from leading edge to trailing edge. If twist_about_positive_y is true, chord_uvec will initially be pointed in the negative-z direction, and then rotated around the positive y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the positive x axis.) If twist_about_positive_y is false, chord_uvec will initially be pointed in the positive-z direction, and then rotated around the negative y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the negative x axis.)

Note that, for a proper noise prediction, the source element needs to be transformed into the "global" frame, aka, the reference frame of the fluid. This can be done easily with the transformations provided by the KinematicCoordinateTransformations package, or manually by modifying the components of the source element struct.

Arguments

• c0: Ambient speed of sound (m/s)
• nu: Kinematic viscosity (m^2/s)
• r: radial coordinate of the element in the blade-fixed coordinate system (m)
• θ: angular offest of the element in the blade-fixed coordinate system (rad)
• Δr: length of the element (m)
• chord: chord length of blade element (m)
• ϕ: twist of blade element (rad)
• h: trailing edge thickness (m)
• Psi: solid angle between the blade surfaces immediately upstream of the trailing edge (rad)
• U: velocity magnitude (m/s)
• α: angle of attack (rad)
• τ: source time (s)
• Δτ: source time duration (s)
• bl: Boundary layer struct, i.e. an AbstractBoundaryLayer.
• twistaboutpositive_y: if true, apply twist ϕ about positive y axis, negative y axis otherwise

CombinedNoTipBroadbandSourceElement(c0, nu, r, θ, Δr, chord, ϕ, h, Psi, vn, vr, vc, τ, Δτ, bl, twist_about_positive_y)

Construct a source element for predicting turbulent boundary layer-trailing edge (TBLTE), laminar boundary layer-vortex shedding (LBLVS) noise, and trailing edge bluntness-vortex shedding (TEBVS) noise using the BPM/Brooks and Burley method, using position and velocity data expressed in a cylindrical coordinate system.

The r and θ arguments are used to define the radial and circumferential position of the source element in a cylindrical coordinate system. Likewise, the vn, vr, and vc arguments are used to define the normal, radial, and circumferential velocity of the fluid (in a reference frame moving with the element) in the same cylindrical coordinate system. The cylindrical coordinate system is defined as follows:

• The normal/axial direction is in the positive x axis
• The circumferential/azimuth angle θ is defined such that θ = 0 means the radial direction is aligned with the positive y axis, and a positive θ indicates a right-handed rotation around the positive x axis.

The twist_about_positive_y is a Bool controling how the ϕ argument is handled, which in turn controls the orientation of a unit vector defining chord_uvec indicating the orientation of the chord line, from leading edge to trailing edge. If twist_about_positive_y is true, chord_uvec will initially be pointed in the negative-z direction, and then rotated around the positive y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the positive x axis.) If twist_about_positive_y is false, chord_uvec will initially be pointed in the positive-z direction, and then rotated around the negative y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the negative x axis.)

Note that, for a proper noise prediction, the source element needs to be transformed into the "global" frame, aka, the reference frame of the fluid. This can be done easily with the transformations provided by the KinematicCoordinateTransformations package, or manually by modifying the components of the source element struct.

Arguments

• c0: Ambient speed of sound (m/s)
• nu: Kinematic viscosity (m^2/s)
• r: radial coordinate of the element in the blade-fixed coordinate system (m)
• θ: angular offest of the element in the blade-fixed coordinate system (rad)
• Δr: length of the element (m)
• chord: chord length of blade element (m)
• ϕ: twist of blade element (rad)
• h: trailing edge thickness (m)
• Psi: solid angle between the blade surfaces immediately upstream of the trailing edge (rad)
• vn: normal velocity of fluid (m/s)
• vr: radial velocity of fluid (m/s)
• vc: circumferential velocity of the fluid (m/s)
• τ: source time (s)
• Δτ: source time duration (s)
• bl: Boundary layer struct, i.e. an AbstractBoundaryLayer.
• twistaboutpositive_y: if true, apply twist ϕ about positive y axis, negative y axis otherwise

CombinedNoTipOutput(G_s, G_p, G_alpha, G_teb, cbands, dt, t)

Output of the combined broadband noise calculation not including tip vortex noise: the acoustic pressure autospectrum centered at time t over observer duration dt and observer frequencies cbands for the TBLTE suction side G_s, TBLTE pressure side G_p, TBLTE separation noise G_alpha, and trailing edge bluntness noise G_teb.

CombinedWithTipBroadbandSourceElement(rotor::CCBlade.Rotor, section::CCBlade.Section, op::CCBlade.OperatingPoint, out::CCBlade.Outputs, θ, Δr, h, Psi, τ, Δτ, bl::AbstractBoundaryLayer, blade_tip::AbstractBladeTip, positive_x_rotation)

Construct a source element for predicting turbulent boundary layer-trailing edge (TBLTE), laminar boundary layer-vortex shedding (LBLVS) noise, trailing edge bluntness-vortex shedding (TEBVS), and tip vortex noise using the BPM/Brooks and Burley method from CCBlade structs.

The source element's position is calculated from section.r, rotor.precone, and the θ argument using

    sθ, cθ = sincos(θ)
    spc, cpc = sincos(precone)
    y0dot = [r*spc, r*cpc*cθ, r*cpc*sθ]

where y0dot is the position of the source element.

Arguments

• rotor::CCBlade.Rotor: CCBlade rotor object, needed for the precone angle.
• section::CCBlade.Section: CCBlade section object, needed for the radial location and chord length of the element.
• op::CCBlade.OperatingPoint: CCBlade operating point, needed for atmospheric properties.
• out::CCBlade.Outputs: CCBlade outputs object, needed for the loading.
• θ: polar coordinate of the element, in radians.
• Δr: length of the element, in meters.
• h: trailing edge thickness (m)
• Psi: solid angle between the blade surfaces immediately upstream of the trailing edge (rad)
• τ: source time of the element, in seconds.
• Δτ: source time duration, in seconds.
• bl: AcousticAnalogies.AbstractBoundaryLayer, needed for boundary layer properties.
• blade_tip: Blade tip struct, i.e. an AbstractBladeTip.
• positive_x_rotation: rotate blade around the positive-x axis if true, negative-x axis otherwise.

CombinedWithTipBroadbandSourceElement(c0, nu, r, θ, Δr, chord, ϕ, h, Psi, U, α, τ, Δτ, bl, blade_tip, twist_about_positive_y)

Construct a source element for predicting turbulent boundary layer-trailing edge (TBLTE), laminar boundary layer-vortex shedding (LBLVS) noise, trailing edge bluntness-vortex shedding (TEBVS), and tip vortex noise using the BPM/Brooks and Burley method, using the velocity magnitude U and angle of attack α.

The r and θ arguments are used to define the radial and circumferential position of the source element in a cylindrical coordinate system. The U and α arguments are the velocity magnitude normal to the source element length and the angle of attack, respectively. The cylindrical coordinate system is defined as follows:

• The normal/axial direction is in the positive x axis
• The circumferential/azimuth angle θ is defined such that θ = 0 means the radial direction is aligned with the positive y axis, and a positive θ indicates a right-handed rotation around the positive x axis.

The twist_about_positive_y is a Bool controling how the ϕ argument is handled, which in turn controls the orientation of a unit vector defining chord_uvec indicating the orientation of the chord line, from leading edge to trailing edge. If twist_about_positive_y is true, chord_uvec will initially be pointed in the negative-z direction, and then rotated around the positive y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the positive x axis.) If twist_about_positive_y is false, chord_uvec will initially be pointed in the positive-z direction, and then rotated around the negative y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the negative x axis.)

Note that, for a proper noise prediction, the source element needs to be transformed into the "global" frame, aka, the reference frame of the fluid. This can be done easily with the transformations provided by the KinematicCoordinateTransformations package, or manually by modifying the components of the source element struct.

Arguments

• c0: Ambient speed of sound (m/s)
• nu: Kinematic viscosity (m^2/s)
• r: radial coordinate of the element in the blade-fixed coordinate system (m)
• θ: angular offest of the element in the blade-fixed coordinate system (rad)
• Δr: length of the element (m)
• chord: chord length of blade element (m)
• ϕ: twist of blade element (rad)
• h: trailing edge thickness (m)
• Psi: solid angle between the blade surfaces immediately upstream of the trailing edge (rad)
• U: velocity magnitude (m/s)
• α: angle of attack (rad)
• τ: source time (s)
• Δτ: source time duration (s)
• bl: Boundary layer struct, i.e. an AbstractBoundaryLayer.
• blade_tip: Blade tip struct, i.e. an AbstractBladeTip
• twistaboutpositive_y: if true, apply twist ϕ about positive y axis, negative y axis otherwise

CombinedWithTipBroadbandSourceElement(c0, nu, r, θ, Δr, chord, ϕ, h, Psi, vn, vr, vc, τ, Δτ, bl, twist_about_positive_y)

Construct a source element for predicting turbulent boundary layer-trailing edge (TBLTE), laminar boundary layer-vortex shedding (LBLVS) noise, trailing edge bluntness-vortex shedding (TEBVS) noise, and tip vortex noise using the BPM/Brooks and Burley method, using position and velocity data expressed in a cylindrical coordinate system.

The r and θ arguments are used to define the radial and circumferential position of the source element in a cylindrical coordinate system. Likewise, the vn, vr, and vc arguments are used to define the normal, radial, and circumferential velocity of the fluid (in a reference frame moving with the element) in the same cylindrical coordinate system. The cylindrical coordinate system is defined as follows:

• The normal/axial direction is in the positive x axis
• The circumferential/azimuth angle θ is defined such that θ = 0 means the radial direction is aligned with the positive y axis, and a positive θ indicates a right-handed rotation around the positive x axis.

The twist_about_positive_y is a Bool controling how the ϕ argument is handled, which in turn controls the orientation of a unit vector defining chord_uvec indicating the orientation of the chord line, from leading edge to trailing edge. If twist_about_positive_y is true, chord_uvec will initially be pointed in the negative-z direction, and then rotated around the positive y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the positive x axis.) If twist_about_positive_y is false, chord_uvec will initially be pointed in the positive-z direction, and then rotated around the negative y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the negative x axis.)

Note that, for a proper noise prediction, the source element needs to be transformed into the "global" frame, aka, the reference frame of the fluid. This can be done easily with the transformations provided by the KinematicCoordinateTransformations package, or manually by modifying the components of the source element struct.

Arguments

• c0: Ambient speed of sound (m/s)
• nu: Kinematic viscosity (m^2/s)
• r: radial coordinate of the element in the blade-fixed coordinate system (m)
• θ: angular offest of the element in the blade-fixed coordinate system (rad)
• Δr: length of the element (m)
• chord: chord length of blade element (m)
• ϕ: twist of blade element (rad)
• h: trailing edge thickness (m)
• Psi: solid angle between the blade surfaces immediately upstream of the trailing edge (rad)
• vn: normal velocity of fluid (m/s)
• vr: radial velocity of fluid (m/s)
• vc: circumferential velocity of the fluid (m/s)
• τ: source time (s)
• Δτ: source time duration (s)
• bl: Boundary layer struct, i.e. an AbstractBoundaryLayer.
• blade_tip: Blade tip struct, i.e. an AbstractBladeTip.
• twistaboutpositive_y: if true, apply twist ϕ about positive y axis, negative y axis otherwise

CombinedWithTipOutput(G_s, G_p, G_alpha, G_teb, G_tip, cbands, dt, t)

Output of the combined broadband noise calculation: the acoustic pressure autospectrum centered at time t over observer duration dt and observer frequencies cbands for the TBLTE suction side G_s, TBLTE pressure side G_p, TBLTE separation noise G_alpha, trailing edge bluntness noise G_teb, and tip vortex noise G_tip.

CompactF1ASourceElement(ρ0, c0, r, θ, Δr, Λ, fn, fr, fc, τ)

Construct a source element to be used with the compact form of Farassat's formulation 1A, using position and loading data expressed in a cylindrical coordinate system.

The r and θ arguments are used to define the radial and circumferential position of the source element in a cylindrical coordinate system. Likewise, the fn, fr, and fc arguments are used to define the normal, radial, and circumferential loading per unit span on the fluid (in a reference frame moving with the element) in the same cylindrical coordinate system. The cylindrical coordinate system is defined as follows:

• The normal axial direction is in the positive x axis
• The circumferential/azimuth angle θ is defined such that θ = 0 means the radial direction is aligned with the positive y axis, and a positive θ indicates a right-handed rotation around the positive x axis.

Note that, for a proper noise prediction, the source element needs to be transformed into the "global" frame, aka, the reference frame of the fluid. This can be done easily with the transformations provided by the KinematicCoordinateTransformations package, or manually by modifying the components of the source element struct.

Arguments

• ρ0: Ambient air density (kg/m^3)
• c0: Ambient speed of sound (m/s)
• r: radial coordinate of the element in the blade-fixed coordinate system (m)
• θ: angular offest of the element in the blade-fixed coordinate system (rad)
• Δr: length of the element (m)
• Λ: cross-sectional area of the element (m^2)
• fn: normal load per unit span on the fluid (N/m)
• fr: radial load on the fluid (N/m)
• fc: circumferential load on the fluid (N/m)
• τ: source time (s)

CompactF1ASourceElement(ρ0, c0, r, θ, Δr, Λ, fn, fndot, fr, frdot, fc, fcdot, τ)

Construct a source element to be used with the compact form of Farassat's formulation 1A, using position and loading data expressed in a cylindrical coordinate system.

The r and θ arguments are used to define the radial and circumferential position of the source element in a cylindrical coordinate system. Likewise, the fn, fr, and fc arguments are used to define the normal, radial, and circumferential loading per unit span on the fluid (in a reference frame moving with the element) in the same cylindrical coordinate system. The fndot, frdot, and fcdot arguments are the time-derivative of the normal, radial, and circumferential loading per unit span, again on the fluid and in a reference frame moving with the element, in the cylindrical coordinate system. The cylindrical coordinate system is defined as follows:

• The normal axial direction is in the positive x axis
• The circumferential/azimuth angle θ is defined such that θ = 0 means the radial direction is aligned with the positive y axis, and a positive θ indicates a right-handed rotation around the positive x axis.

Note that, for a proper noise prediction, the source element needs to be transformed into the "global" frame, aka, the reference frame of the fluid. This can be done easily with the transformations provided by the KinematicCoordinateTransformations package, or manually by modifying the components of the source element struct.

Arguments

• ρ0: Ambient air density (kg/m^3)
• c0: Ambient speed of sound (m/s)
• r: radial coordinate of the element in the blade-fixed coordinate system (m)
• θ: angular offest of the element in the blade-fixed coordinate system (rad)
• Δr: length of the element (m)
• Λ: cross-sectional area of the element (m^2)
• fn: normal load per unit span on the fluid (N/m)
• fndot: time derivative of the normal load per unit span on the fluid (N/(m*s))
• fr: radial load on the fluid (N/m)
• frdot: time derivative of the radial load on the fluid (N/(m*s))
• fc: circumferential load on the fluid (N/m)
• fcdot: time derivative of the circumferential load on the fluid (N/(m*s))
• τ: source time (s)

CompactF1ASourceElement(rotor::CCBlade.Rotor, section::CCBlade.Section, op::CCBlade.OperatingPoint, out::CCBlade.Outputs, θ, Δr, area_per_chord2, τ, positive_x_rotation=true)

Construct a source element to be used with the compact form of Farassat's formulation 1A from CCBlade objects.

The source element's position is calculated from section.r, rotor.precone, and the θ argument using

    sθ, cθ = sincos(θ)
    spc, cpc = sincos(precone)
    y0dot = [r*spc, r*cpc*cθ, r*cpc*sθ]

where y0dot is the position of the source element.

Arguments

• rotor::CCBlade.Rotor: CCBlade rotor object, needed for the precone angle.precone.
• section::CCBlade.Section: CCBlade section object, needed for the radial location and chord length of the element.
• op::CCBlade.OperatingPoint: CCBlade operating point, needed for atmospheric properties.
• out::CCBlade.Outputs: CCBlade outputs object, needed for the loading.
• θ: polar coordinate of the element, in radians.
• Δr: length of the element.
• area_per_chord2: cross-sectional area divided by the chord squared of the element.
• τ: source time of the element.
• positive_x_rotation: rotate blade around the positive-x axis if true, negative-x axis otherwise.

ConstVelocityAcousticObserver(t0, x0, v)

Construct an acoustic observer moving with a constant velocity v, located at x0 at time t0.

Output of the F1A calculation: the acoustic pressure value at time t, broken into monopole component p_m and dipole component p_d.

F1APressureTimeHistory(apth::AbstractArray{<:F1AOutput}, period::AbstractFloat, n::Integer, axis::Integer=1)

Construct an F1APressureTimeHistory struct suitable for containing an acoustic prediction from an array of F1AOutput struct.

The elapsed time and length of the returned F1APressureTimeHistory will be period and n, respectively. axis indicates which axis the apth structs time varies. (period, n, axis are passed to common_obs_time.)

F1APressureTimeHistory([T=Float64,] n, dt, t0)

Construct an F1APressureTimeHistory struct suitable for containing an acoustic prediction of length n, starting at time t0 with time step dt.

LBLVSSourceElement(rotor::CCBlade.Rotor, section::CCBlade.Section, op::CCBlade.OperatingPoint, out::CCBlade.Outputs, θ, Δr, τ, Δτ, bl::AbstractBoundaryLayer, positive_x_rotation)

Construct a source element to be used to predict laminary boundary layer-vortex shedding (LBLVS) noise.

The source element's position is calculated from section.r, rotor.precone, and the θ argument using

    sθ, cθ = sincos(θ)
    spc, cpc = sincos(precone)
    y0dot = [r*spc, r*cpc*cθ, r*cpc*sθ]

where y0dot is the position of the source element.

Arguments

• rotor::CCBlade.Rotor: CCBlade rotor object, needed for the precone angle.
• section::CCBlade.Section: CCBlade section object, needed for the radial location and chord length of the element.
• op::CCBlade.OperatingPoint: CCBlade operating point, needed for atmospheric properties.
• out::CCBlade.Outputs: CCBlade outputs object, needed for the loading.
• θ: polar coordinate of the element, in radians.
• Δr: length of the element, in meters.
• τ: source time of the element, in seconds.
• Δτ: source time duration, in seconds.
• bl: AcousticAnalogies.AbstractBoundaryLayer, needed for boundary layer properties.
• positive_x_rotation: rotate blade around the positive-x axis if true, negative-x axis otherwise.

LBLVSSourceElement(c0, nu, r, θ, Δr, chord, ϕ, U, α, τ, Δτ, bl, twist_about_positive_y)

Construct a source element for predicting laminar boundary layer-vortex shedding (LBLVS) noise using the BPM/Brooks and Burley method, using the velocity magnitude U and angle of attack α.

The r and θ arguments are used to define the radial and circumferential position of the source element in a cylindrical coordinate system. The U and α arguments are the velocity magnitude normal to the source element length and the angle of attack, respectively. The cylindrical coordinate system is defined as follows:

• The normal/axial direction is in the positive x axis
• The circumferential/azimuth angle θ is defined such that θ = 0 means the radial direction is aligned with the positive y axis, and a positive θ indicates a right-handed rotation around the positive x axis.

The twist_about_positive_y is a Bool controling how the ϕ argument is handled, which in turn controls the orientation of a unit vector defining chord_uvec indicating the orientation of the chord line, from leading edge to trailing edge. If twist_about_positive_y is true, chord_uvec will initially be pointed in the negative-z direction, and then rotated around the positive y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the positive x axis.) If twist_about_positive_y is false, chord_uvec will initially be pointed in the positive-z direction, and then rotated around the negative y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the negative x axis.)

Note that, for a proper noise prediction, the source element needs to be transformed into the "global" frame, aka, the reference frame of the fluid. This can be done easily with the transformations provided by the KinematicCoordinateTransformations package, or manually by modifying the components of the source element struct.

Arguments

• c0: Ambient speed of sound (m/s)
• nu: Kinematic viscosity (m^2/s)
• r: radial coordinate of the element in the blade-fixed coordinate system (m)
• θ: angular offest of the element in the blade-fixed coordinate system (rad)
• Δr: length of the element (m)
• chord: chord length of blade element (m)
• ϕ: twist of blade element (rad)
• U: velocity magnitude (m/s)
• α: angle of attack (rad)
• τ: source time (s)
• Δτ: source time duration (s)
• bl: Boundary layer struct, i.e. an AbstractBoundaryLayer.
• twistaboutpositive_y: if true, apply twist ϕ about positive y axis, negative y axis otherwise

LBLVSSourceElement(c0, nu, r, θ, Δr, chord, ϕ, vn, vr, vc, τ, Δτ, bl, twist_about_positive_y)

Construct a source element for predicting laminar boundary layer-vortex shedding (LBLVS) noise using the BPM/Brooks and Burley method, using position and velocity data expressed in a cylindrical coordinate system.

The r and θ arguments are used to define the radial and circumferential position of the source element in a cylindrical coordinate system. Likewise, the vn, vr, and vc arguments are used to define the normal, radial, and circumferential velocity of the fluid (in a reference frame moving with the element) in the same cylindrical coordinate system. The cylindrical coordinate system is defined as follows:

• The normal/axial direction is in the positive x axis
• The circumferential/azimuth angle θ is defined such that θ = 0 means the radial direction is aligned with the positive y axis, and a positive θ indicates a right-handed rotation around the positive x axis.

The twist_about_positive_y is a Bool controling how the ϕ argument is handled, which in turn controls the orientation of a unit vector defining chord_uvec indicating the orientation of the chord line, from leading edge to trailing edge. If twist_about_positive_y is true, chord_uvec will initially be pointed in the negative-z direction, and then rotated around the positive y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the positive x axis.) If twist_about_positive_y is false, chord_uvec will initially be pointed in the positive-z direction, and then rotated around the negative y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the negative x axis.)

Note that, for a proper noise prediction, the source element needs to be transformed into the "global" frame, aka, the reference frame of the fluid. This can be done easily with the transformations provided by the KinematicCoordinateTransformations package, or manually by modifying the components of the source element struct.

Arguments

• c0: Ambient speed of sound (m/s)
• nu: Kinematic viscosity (m^2/s)
• r: radial coordinate of the element in the blade-fixed coordinate system (m)
• θ: angular offest of the element in the blade-fixed coordinate system (rad)
• Δr: length of the element (m)
• chord: chord length of blade element (m)
• ϕ: twist of blade element (rad)
• vn: normal velocity of fluid (m/s)
• vr: radial velocity of fluid (m/s)
• vc: circumferential velocity of the fluid (m/s)
• τ: source time (s)
• Δτ: source time duration (s)
• bl: Boundary layer struct, i.e. an AbstractBoundaryLayer.
• twistaboutpositive_y: if true, apply twist ϕ about positive y axis, negative y axis otherwise

Struct for holding data from an OpenFAST (AeroDyn?) output file.

Fields:

• time: vector of simulation times with size (num_times,)
• dtime_dtau: vector of derivative of simulation times with respect to non-dimensional/computational time with size (num_times,)
• v: vector of freestream velocity time history with size (num_times,)
• azimuth: vector of azimuth angle time history with size (num_times,)
• omega: vector of rotation rate time history with size (num_times,)
• pitch: array of pitch angle time history with size (num_times, num_blades)
• radii: vector of blade radial locations with size (num_radial,)
• radii_mid: vector of cell-centered/midpoint blade radial locations with size (num_radial-1,)
• cs_area: vector of cross-sectional areas with size (num_radial,).
• cs_area_mid: vector of cell-centered/midpoint cross-sectional areas with size (num_radial-1,).
• axial_loading: array of axial loading time history with size (num_times, num_radial, num_blades)
• axial_loading_mid: array of axial loading time history at cell-centered blade radial locations with size (num_times, num_radial-1, num_blades)
• axial_loading_mid_dot: array of axial loading temporal derivative time history at cell-centered blade radial locations with size (num_times, num_radial-1, num_blades)
• circum_loading: array of circumferential loading time history with size (num_times, num_radial, num_blades)
• circum_loading_mid: array of circum loading time history at cell-centered blade radial locations with size (num_times, num_radial-1, num_blades)
• circum_loading_mid_dot: array of circum loading temporal derivative time history at cell-centered blade radial locations with size (num_times, num_radial-1, num_blades)

StationaryAcousticObserver(x)

Construct an acoustic observer that does not move with position x (m).

Output of the turbulent boundary layer-trailing edge (TBL-TE) calculation: the acoustic pressure autospectrum centered at time t over observer duration dt and observer frequencies cbands for the suction side G_s, pressure side G_p, and the separation G_alpha.

TBLTESourceElement(rotor::CCBlade.Rotor, section::CCBlade.Section, op::CCBlade.OperatingPoint, out::CCBlade.Outputs, θ, Δr, τ, Δτ, bl::AbstractBoundaryLayer, positive_x_rotation)

Construct a source element to be used to predict turbulent boundary layer-trailing edge (TBLTE) noise.

The source element's position is calculated from section.r, rotor.precone, and the θ argument using

    sθ, cθ = sincos(θ)
    spc, cpc = sincos(precone)
    y0dot = [r*spc, r*cpc*cθ, r*cpc*sθ]

where y0dot is the position of the source element.

Arguments

• rotor::CCBlade.Rotor: CCBlade rotor object, needed for the precone angle.
• section::CCBlade.Section: CCBlade section object, needed for the radial location and chord length of the element.
• op::CCBlade.OperatingPoint: CCBlade operating point, needed for atmospheric properties.
• out::CCBlade.Outputs: CCBlade outputs object, needed for the loading.
• θ: polar coordinate of the element, in radians.
• Δr: length of the element, in meters.
• τ: source time of the element, in seconds.
• Δτ: source time duration, in seconds.
• bl: AcousticAnalogies.AbstractBoundaryLayer, needed for boundary layer properties.
• positive_x_rotation: rotate blade around the positive-x axis if true, negative-x axis otherwise.

TBLTESourceElement(c0, nu, r, θ, Δr, chord, ϕ, U, α, τ, Δτ, bl, twist_about_positive_y)

Construct a source element for predicting turbulent boundary layer-trailing edge (TBLTE) noise using the BPM/Brooks and Burley method, using the velocity magnitude U and angle of attack α.

The r and θ arguments are used to define the radial and circumferential position of the source element in a cylindrical coordinate system. The U and α arguments are the velocity magnitude normal to the source element length and the angle of attack, respectively. The cylindrical coordinate system is defined as follows:

• The normal/axial direction is in the positive x axis
• The circumferential/azimuth angle θ is defined such that θ = 0 means the radial direction is aligned with the positive y axis, and a positive θ indicates a right-handed rotation around the positive x axis.

The twist_about_positive_y is a Bool controling how the ϕ argument is handled, which in turn controls the orientation of a unit vector defining chord_uvec indicating the orientation of the chord line, from leading edge to trailing edge. If twist_about_positive_y is true, chord_uvec will initially be pointed in the negative-z direction, and then rotated around the positive y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the positive x axis.) If twist_about_positive_y is false, chord_uvec will initially be pointed in the positive-z direction, and then rotated around the negative y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the negative x axis.)

Note that, for a proper noise prediction, the source element needs to be transformed into the "global" frame, aka, the reference frame of the fluid. This can be done easily with the transformations provided by the KinematicCoordinateTransformations package, or manually by modifying the components of the source element struct.

Arguments

• c0: Ambient speed of sound (m/s)
• nu: Kinematic viscosity (m^2/s)
• r: radial coordinate of the element in the blade-fixed coordinate system (m)
• θ: angular offest of the element in the blade-fixed coordinate system (rad)
• Δr: length of the element (m)
• chord: chord length of blade element (m)
• ϕ: twist of blade element (rad)
• U: velocity magnitude (m/s)
• α: angle of attack (rad)
• τ: source time (s)
• Δτ: source time duration (s)
• bl: Boundary layer struct, i.e. an AbstractBoundaryLayer.
• twistaboutpositive_y: if true, apply twist ϕ about positive y axis, negative y axis otherwise

TBLTESourceElement(c0, nu, r, θ, Δr, chord, ϕ, vn, vr, vc, τ, Δτ, bl, twist_about_positive_y)

Construct a source element for predicting turbulent boundary layer-trailing edge (TBLTE) noise using the BPM/Brooks and Burley method, using position and velocity data expressed in a cylindrical coordinate system.

The r and θ arguments are used to define the radial and circumferential position of the source element in a cylindrical coordinate system. Likewise, the vn, vr, and vc arguments are used to define the normal, radial, and circumferential velocity of the fluid (in a reference frame moving with the element) in the same cylindrical coordinate system. The cylindrical coordinate system is defined as follows:

• The normal/axial direction is in the positive x axis
• The circumferential/azimuth angle θ is defined such that θ = 0 means the radial direction is aligned with the positive y axis, and a positive θ indicates a right-handed rotation around the positive x axis.

The twist_about_positive_y is a Bool controling how the ϕ argument is handled, which in turn controls the orientation of a unit vector defining chord_uvec indicating the orientation of the chord line, from leading edge to trailing edge. If twist_about_positive_y is true, chord_uvec will initially be pointed in the negative-z direction, and then rotated around the positive y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the positive x axis.) If twist_about_positive_y is false, chord_uvec will initially be pointed in the positive-z direction, and then rotated around the negative y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the negative x axis.)

Note that, for a proper noise prediction, the source element needs to be transformed into the "global" frame, aka, the reference frame of the fluid. This can be done easily with the transformations provided by the KinematicCoordinateTransformations package, or manually by modifying the components of the source element struct.

Arguments

• c0: Ambient speed of sound (m/s)
• nu: Kinematic viscosity (m^2/s)
• r: radial coordinate of the element in the blade-fixed coordinate system (m)
• θ: angular offest of the element in the blade-fixed coordinate system (rad)
• Δr: length of the element (m)
• chord: chord length of blade element (m)
• ϕ: twist of blade element (rad)
• vn: normal velocity of fluid (m/s)
• vr: radial velocity of fluid (m/s)
• vc: circumferential velocity of the fluid (m/s)
• τ: source time (s)
• Δτ: source time duration (s)
• bl: Boundary layer struct, i.e. an AbstractBoundaryLayer.
• twistaboutpositive_y: if true, apply twist ϕ about positive y axis, negative y axis otherwise

TEBVSSourceElement(rotor::CCBlade.Rotor, section::CCBlade.Section, op::CCBlade.OperatingPoint, out::CCBlade.Outputs, θ, Δr, h, Psi, τ, Δτ, bl::AbstractBoundaryLayer, positive_x_rotation)

Construct a source element to be used to predict trailing edge bluntness-vortex shedding (TEBVS) noise.

The source element's position is calculated from section.r, rotor.precone, and the θ argument using

    sθ, cθ = sincos(θ)
    spc, cpc = sincos(precone)
    y0dot = [r*spc, r*cpc*cθ, r*cpc*sθ]

where y0dot is the position of the source element.

Arguments

• rotor::CCBlade.Rotor: CCBlade rotor object, needed for the precone angle.
• section::CCBlade.Section: CCBlade section object, needed for the radial location and chord length of the element.
• op::CCBlade.OperatingPoint: CCBlade operating point, needed for atmospheric properties.
• out::CCBlade.Outputs: CCBlade outputs object, needed for the loading.
• θ: polar coordinate of the element, in radians.
• Δr: length of the element, in meters.
• h: trailing edge thickness (m)
• Psi: solid angle between the blade surfaces immediately upstream of the trailing edge (rad)
• τ: source time of the element, in seconds.
• Δτ: source time duration, in seconds.
• bl: AcousticAnalogies.AbstractBoundaryLayer, needed for boundary layer properties.
• positive_x_rotation: rotate blade around the positive-x axis if true, negative-x axis otherwise.

TEBVSSourceElement(c0, nu, r, θ, Δr, chord, ϕ, h, Psi, U, α, τ, Δτ, bl, twist_about_positive_y)

Construct a source element for predicting trailing edge bluntness-vortex shedding (TEBVS) noise using the BPM/Brooks and Burley method, using the velocity magnitude U and angle of attack α.

The r and θ arguments are used to define the radial and circumferential position of the source element in a cylindrical coordinate system. The U and α arguments are the velocity magnitude normal to the source element length and the angle of attack, respectively. The cylindrical coordinate system is defined as follows:

• The normal/axial direction is in the positive x axis
• The circumferential/azimuth angle θ is defined such that θ = 0 means the radial direction is aligned with the positive y axis, and a positive θ indicates a right-handed rotation around the positive x axis.

The twist_about_positive_y is a Bool controling how the ϕ argument is handled, which in turn controls the orientation of a unit vector defining chord_uvec indicating the orientation of the chord line, from leading edge to trailing edge. If twist_about_positive_y is true, chord_uvec will initially be pointed in the negative-z direction, and then rotated around the positive y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the positive x axis.) If twist_about_positive_y is false, chord_uvec will initially be pointed in the positive-z direction, and then rotated around the negative y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the negative x axis.)

Note that, for a proper noise prediction, the source element needs to be transformed into the "global" frame, aka, the reference frame of the fluid. This can be done easily with the transformations provided by the KinematicCoordinateTransformations package, or manually by modifying the components of the source element struct.

Arguments

• c0: Ambient speed of sound (m/s)
• nu: Kinematic viscosity (m^2/s)
• r: radial coordinate of the element in the blade-fixed coordinate system (m)
• θ: angular offest of the element in the blade-fixed coordinate system (rad)
• Δr: length of the element (m)
• chord: chord length of blade element (m)
• ϕ: twist of blade element (rad)
• h: trailing edge thickness (m)
• Psi: solid angle between the blade surfaces immediately upstream of the trailing edge (rad)
• U: velocity magnitude (m/s)
• α: angle of attack (rad)
• τ: source time (s)
• Δτ: source time duration (s)
• bl: Boundary layer struct, i.e. an AbstractBoundaryLayer.
• twistaboutpositive_y: if true, apply twist ϕ about positive y axis, negative y axis otherwise

TEBVSSourceElement(c0, nu, r, θ, Δr, chord, ϕ, h, Psi, vn, vr, vc, τ, Δτ, bl, twist_about_positive_y)

Construct a source element for predicting trailing edge bluntness-vortex shedding (TEBVS) noise using the BPM/Brooks and Burley method, using position and velocity data expressed in a cylindrical coordinate system.

The r and θ arguments are used to define the radial and circumferential position of the source element in a cylindrical coordinate system. Likewise, the vn, vr, and vc arguments are used to define the normal, radial, and circumferential velocity of the fluid (in a reference frame moving with the element) in the same cylindrical coordinate system. The cylindrical coordinate system is defined as follows:

• The normal/axial direction is in the positive x axis
• The circumferential/azimuth angle θ is defined such that θ = 0 means the radial direction is aligned with the positive y axis, and a positive θ indicates a right-handed rotation around the positive x axis.

The twist_about_positive_y is a Bool controling how the ϕ argument is handled, which in turn controls the orientation of a unit vector defining chord_uvec indicating the orientation of the chord line, from leading edge to trailing edge. If twist_about_positive_y is true, chord_uvec will initially be pointed in the negative-z direction, and then rotated around the positive y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the positive x axis.) If twist_about_positive_y is false, chord_uvec will initially be pointed in the positive-z direction, and then rotated around the negative y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the negative x axis.)

Note that, for a proper noise prediction, the source element needs to be transformed into the "global" frame, aka, the reference frame of the fluid. This can be done easily with the transformations provided by the KinematicCoordinateTransformations package, or manually by modifying the components of the source element struct.

Arguments

• c0: Ambient speed of sound (m/s)
• nu: Kinematic viscosity (m^2/s)
• r: radial coordinate of the element in the blade-fixed coordinate system (m)
• θ: angular offest of the element in the blade-fixed coordinate system (rad)
• Δr: length of the element (m)
• chord: chord length of blade element (m)
• ϕ: twist of blade element (rad)
• h: trailing edge thickness (m)
• Psi: solid angle between the blade surfaces immediately upstream of the trailing edge (rad)
• vn: normal velocity of fluid (m/s)
• vr: radial velocity of fluid (m/s)
• vc: circumferential velocity of the fluid (m/s)
• τ: source time (s)
• Δτ: source time duration (s)
• bl: Boundary layer struct, i.e. an AbstractBoundaryLayer.
• twistaboutpositive_y: if true, apply twist ϕ about positive y axis, negative y axis otherwise

TipVortexSourceElement(rotor::CCBlade.Rotor, section::CCBlade.Section, op::CCBlade.OperatingPoint, out::CCBlade.Outputs, θ, Δr, τ, Δτ, bl::AbstractBoundaryLayer, blade_tip::AbstractBladeTip, positive_x_rotation)

Construct a source element to be used to predict tip vortex noise.

The source element's position is calculated from section.r, rotor.precone, and the θ argument using

    sθ, cθ = sincos(θ)
    spc, cpc = sincos(precone)
    y0dot = [r*spc, r*cpc*cθ, r*cpc*sθ]

where y0dot is the position of the source element.

Arguments

• rotor::CCBlade.Rotor: CCBlade rotor object, needed for the precone angle.
• section::CCBlade.Section: CCBlade section object, needed for the radial location and chord length of the element.
• op::CCBlade.OperatingPoint: CCBlade operating point, needed for atmospheric properties.
• out::CCBlade.Outputs: CCBlade outputs object, needed for the loading.
• θ: polar coordinate of the element, in radians.
• Δr: length of the element, in meters.
• τ: source time of the element, in seconds.
• Δτ: source time duration, in seconds.
• bl: AcousticAnalogies.AbstractBoundaryLayer, needed for boundary layer properties.
• blade_tip: AcousticAnalogies.AbstractBladeTip
• positive_x_rotation: rotate blade around the positive-x axis if true, negative-x axis otherwise.

TipVortexSourceElement(c0, r, θ, Δr, chord, ϕ, U, α, τ, Δτ, bl, blade_tip, twist_about_positive_y)

Construct a source element for predicting tip vortex noise using the BPM/Brooks and Burley method, using the velocity magnitude U and angle of attack α.

The r and θ arguments are used to define the radial and circumferential position of the source element in a cylindrical coordinate system. The U and α arguments are the velocity magnitude normal to the source element length and the angle of attack, respectively. The cylindrical coordinate system is defined as follows:

• The normal/axial direction is in the positive x axis
• The circumferential/azimuth angle θ is defined such that θ = 0 means the radial direction is aligned with the positive y axis, and a positive θ indicates a right-handed rotation around the positive x axis.

The twist_about_positive_y is a Bool controling how the ϕ argument is handled, which in turn controls the orientation of a unit vector defining chord_uvec indicating the orientation of the chord line, from leading edge to trailing edge. If twist_about_positive_y is true, chord_uvec will initially be pointed in the negative-z direction, and then rotated around the positive y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the positive x axis.) If twist_about_positive_y is false, chord_uvec will initially be pointed in the positive-z direction, and then rotated around the negative y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the negative x axis.)

Note that, for a proper noise prediction, the source element needs to be transformed into the "global" frame, aka, the reference frame of the fluid. This can be done easily with the transformations provided by the KinematicCoordinateTransformations package, or manually by modifying the components of the source element struct.

Arguments

• c0: Ambient speed of sound (m/s)
• r: radial coordinate of the element in the blade-fixed coordinate system (m)
• θ: angular offest of the element in the blade-fixed coordinate system (rad)
• Δr: length of the element (m)
• chord: chord length of blade element (m)
• ϕ: twist of blade element (rad)
• U: velocity magnitude (m/s)
• α: angle of attack (rad)
• τ: source time (s)
• Δτ: source time duration (s)
• bl: Boundary layer struct, i.e. an AbstractBoundaryLayer.
• blade_tip: Blade tip struct, i.e. an AbstractBladeTip.
• twistaboutpositive_y: if true, apply twist ϕ about positive y axis, negative y axis otherwise

TipVortexSourceElement(c0, r, θ, Δr, chord, ϕ, vn, vr, vc, τ, Δτ, bl, blade_tip, twist_about_positive_y)

Construct a source element for predicting turbulent boundary layer-trailing edge (TBLTE) noise using the BPM/Brooks and Burley method, using position and velocity data expressed in a cylindrical coordinate system.

The r and θ arguments are used to define the radial and circumferential position of the source element in a cylindrical coordinate system. Likewise, the vn, vr, and vc arguments are used to define the normal, radial, and circumferential velocity of the fluid (in a reference frame moving with the element) in the same cylindrical coordinate system. The cylindrical coordinate system is defined as follows:

• The normal/axial direction is in the positive x axis
• The circumferential/azimuth angle θ is defined such that θ = 0 means the radial direction is aligned with the positive y axis, and a positive θ indicates a right-handed rotation around the positive x axis.

The twist_about_positive_y is a Bool controling how the ϕ argument is handled, which in turn controls the orientation of a unit vector defining chord_uvec indicating the orientation of the chord line, from leading edge to trailing edge. If twist_about_positive_y is true, chord_uvec will initially be pointed in the negative-z direction, and then rotated around the positive y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the positive x axis.) If twist_about_positive_y is false, chord_uvec will initially be pointed in the positive-z direction, and then rotated around the negative y axis by an amount ϕ before being rotated by the azimuth angle θ. (This would typcially be appropriate for a source element rotating around the negative x axis.)

Note that, for a proper noise prediction, the source element needs to be transformed into the "global" frame, aka, the reference frame of the fluid. This can be done easily with the transformations provided by the KinematicCoordinateTransformations package, or manually by modifying the components of the source element struct.

Arguments

• c0: Ambient speed of sound (m/s)
• r: radial coordinate of the element in the blade-fixed coordinate system (m)
• θ: angular offest of the element in the blade-fixed coordinate system (rad)
• Δr: length of the element (m)
• chord: chord length of blade element (m)
• ϕ: twist of blade element (rad)
• vn: normal velocity of fluid (m/s)
• vr: radial velocity of fluid (m/s)
• vc: circumferential velocity of the fluid (m/s)
• τ: source time (s)
• Δτ: source time duration (s)
• bl: Boundary layer struct, i.e. an AbstractBoundaryLayer.
• blade_tip: Blade tip struct, i.e. an AbstractBladeTip.
• twistaboutpositive_y: if true, apply twist ϕ about positive y axis, negative y axis otherwise

(trans::KinematicTransformation)(se::CompactF1ASourceElement)

Transform the position and forces of a source element according to the coordinate system transformation trans.

(trans::KinematicTransformation)(se::CombinedNoTipBroadbandSourceElement)

Transform the position and orientation of a source element according to the coordinate system transformation trans.

(trans::KinematicTransformation)(se::CombinedWithTipBroadbandSourceElement)

Transform the position and orientation of a source element according to the coordinate system transformation trans.

(trans::KinematicTransformation)(se::LBLVSSourceElement)

Transform the position and orientation of a source element according to the coordinate system transformation trans.

(trans::KinematicTransformation)(se::TBLTESourceElement)

Transform the position and orientation of a source element according to the coordinate system transformation trans.

(trans::KinematicTransformation)(se::TEBVSSourceElement)

Transform the position and orientation of a source element according to the coordinate system transformation trans.

(trans::KinematicTransformation)(se::TipVortexSourceElement)

Transform the position and orientation of a source element according to the coordinate system transformation trans.

adv_time(se::AbstractCompactSourceElement, obs::AbstractAcousticObserver)

Calculate the time an acoustic wave emmited by source se at time se.τ is recieved by observer obs.

combine(apth::AbstractArray{<:F1AOutput}, period::AbstractFloat, n::Integer, time_axis=1; f_interp=akima)

Combine the acoustic pressures of multiple sources (apth) into a single acoustic pressure time history on a time grid of size n extending over time length period.

time_axis is an integer indicating the timeaxis of the apth array along which time varies. For example, if `timeaxis == 1andapthis a three-dimensional array, thenapth[:, i, j]would be theF1AOutputobjects of thei,jsource element for all time. But iftime_axis == 3, thenapth[i, j, :]would be theF1AOutputobjects of thei,j` source element for all time.

combine!(apth_out::F1APressureTimeHistory, apth::AbstractArray{<:F1AOutput}, time_axis; f_interp=akima)

Combine the acoustic pressures of multiple sources (apth) into a single acoustic pressure time history apth_out.

The input acoustic pressures apth are interpolated onto the time grid returned by time(apth_out). The interpolation is performed by the function f_intep(xpt, ypt, x), where xpt and ytp are the input grid and function values, respectively, and x is the output grid. time_axis is an integer indicating the timeaxis of the apth array along which time varies. For example, if `timeaxis == 1andapthis a three-dimensional array, thenapth[:, i, j]would be theF1AOutputobjects of thei,jsource element for all time. But iftime_axis == 3, thenapth[i, j, :]would be theF1AOutputobjects of thei,j` source element for all time.

combined_broadband_source_elements_ccblade(rotor::CCBlade.Rotor, sections::Vector{CCBlade.Section}, ops::Vector{CCBlade.OperatingPoint}, outputs::Vector{CCBlade.Outputs}, hs::Vector{Float64}, Psis::Vector{Float64}, bls::Vector{AbstractBoundaryLayer}, blade_tip::AbstractBladeTip, period, num_src_times, positive_x_rotation)

Construct and return an array of broadband prediction source element objects from CCBlade structs.

Arguments

• rotor: CCBlade rotor object.
• sections: Vector of CCBlade section object.
• ops: Vector of CCBlade operating point.
• outputs: Vector of CCBlade output objects.
• hs: Vector of trailing edge thicknesses (m)
• Psis: Vector of solid angles between the blade surfaces immediately upstream of the trailing edge (rad)
• bls::Vector of boundary layer AbstractBoundaryLayer structs.
• blade_tip: Blade tip struct, i.e. an AbstractBladeTip.
• period: length of the source time over which the returned source elements will evaluated.
• num_src_times: number of source times.
• positive_x_rotation: rotate blade around the positive-x axis if true, negative-x axis otherwise.

common_obs_time(apth::AbstractArray{<:F1AOutput}, period, n, axis=1)

Return a suitable time range for the collection of F1A acoustic pressures in apth.

The time range will begin near the latest start time of the acoustic pressures in apth, and be an AbstractVector (really a StepRangeLen) of size n and of time length period. axis indicates which axis of apth the time for a source varies.

doppler_factor(se::AbstractBroadbandSourceElement, obs::AbstractAcousticObserver)

Calculate the Doppler shift factor for noise emitted by source element se and recieved by observer obs, i.e. the ratio between an observer frequency f and emitted frequency f_0.

The correct value for t_obs will be found using adv_time internally.

doppler_factor(se::AbstractBroadbandSourceElement, obs::AbstractAcousticObserver, t_obs)

Calculate the Doppler shift factor for noise emitted by source element se and recieved by observer obs at time t_obs, i.e. the ratio between an observer frequency f and emitted frequency f_0.

The correct value for t_obs can be found using adv_time.

endpoints(se::AbstractCompactSourceElement)

Return the Tuple containing the endpoint locations of the compact source element se.

f1a_source_elements_ccblade(rotor::CCBlade.Rotor, sections::Vector{CCBlade.Section}, ops::Vector{CCBlade.OperatingPoint}, outputs::Vector{CCBlade.Outputs}, area_per_chord2::Vector{AbstractFloat}, period, num_src_times, positive_x_rotation)

Construct and return an array of CompactF1ASourceElement objects from CCBlade structs.

Arguments

• rotor: CCBlade rotor object.
• sections: Vector of CCBlade section object.
• ops: Vector of CCBlade operating point.
• outputs::Vector of CCBlade output objects.
• area_per_chord2: cross-sectional area divided by the chord squared of the element at each CCBlade.section. Should be a Vector{AbstractFloat}, same length as sections, ops, outputs.
• period: length of the source time over which the returned source elements will evaluated.
• num_src_times: number of source times.
• positive_x_rotation: rotate blade around the positive-x axis if true, negative-x axis otherwise.

f1a_source_elements_openfast(data::OpenFASTData, rho0, c0, area_per_chord2::Vector, positive_x_rotation::Bool=true)

Construct and return an array of CompactF1ASourceElement objects from OpenFAST data.

Arguments

• data: OpenFAST data object.
• rho0: Ambient air density (kg/m^3)
• c0: Ambient speed of sound (m/s)
• positive_x_rotation: rotate blade around the positive-x axis if true, negative-x axis otherwise

get_ccblade_dradii(rotor::CCBlade.Rotor, sections::Vector{CCBlade.Section})

Construct and return a Vector of the lengths of each CCBlade section.

get_dradii(radii, Rhub, Rtip)

Compute the spacing between blade elements given the radial locations of the element midpoints in radii and the hub and tip radius in Rhub and Rtip, respectively.

Assume the interfaces between elements are midway between adjacent element's midpoints.

lblvs_source_elements_ccblade(rotor::CCBlade.Rotor, sections::Vector{CCBlade.Section}, ops::Vector{CCBlade.OperatingPoint}, outputs::Vector{CCBlade.Outputs}, bls::Vector{AbstractBoundaryLayer}, period, num_src_times, positive_x_rotation)

Construct and return an array of LBLVSSourceElement objects from CCBlade structs.

Arguments

• rotor: CCBlade rotor object.
• sections: Vector of CCBlade section object.
• ops: Vector of CCBlade operating point.
• outputs: Vector of CCBlade output objects.
• bls::Vector of boundary layer AbstractBoundaryLayer structs.
• period: length of the source time over which the returned source elements will evaluated.
• num_src_times: number of source times.
• positive_x_rotation: rotate blade around the positive-x axis if true, negative-x axis otherwise.

noise(se::CompactF1ASourceElement, obs::AbstractAcousticObserver, t_obs)

Calculate the acoustic pressure emitted by source element se and recieved by observer obs at time t_obs, returning an F1AOutput object.

The correct value for t_obs can be found using adv_time.

noise(se::CompactF1ASourceElement, obs::AbstractAcousticObserver)

Calculate the acoustic pressure emitted by source element se and recieved by observer obs, returning an F1AOutput object.

orientation(se::AbstractCompactSourceElement)

Return a length-3 unit vector indicating the spanwise orientation of se.

position(se::AbstractCompactSourceElement)

Return a length-3 vector indicating the position of se.

read_openfast_file(fname, radii, cs_area=nothing;
    header_keyword="Time",
    has_units_header=true,
    time_column_name="Time", 
    freestream_vel_column_name="Wind1VelX",
    azimuth_column_name="Azimuth",
    omega_column_name="RotSpeed",
    pitch_fmt=r"BlPitch(?<blade>[[:digit:]]+)",
    axial_loading_fmt=r"AB(?<blade>[[:digit:]]+)N(?<radial>[[:digit:]]+)Fxl",
    circum_loading_fmt=r"AB(?<blade>[[:digit:]]+)N(?<radial>[[:digit:]]+)Fyl",
    radial_interp_method=FLOWLinearInterp,
    time_deriv_method=SecondOrderFiniteDiff)

Read an OpenFAST output file and return a OpenFASTData object.

The Azimuth and BlPitch columns are assumed to be in degrees and will be converted to radians. Likewise, the RotSpeed column is assumed to be in revolutions per minute and will be converted to radians per second.

Arguments

• fname: name of the OpenFAST output file to read
• radii: Vector of blade radial coordinates
• cs_area: Vector of radial distribution of cross-sectional areas, or nothing to ignore
• header_keyword="Time": string at the beginning of the header line (maybe always "Time"?)
• has_units_header=true: if true, assume the file has a line directly after the header line with the units of each column
• time_column_name=header_keyword: name of time column in file. Set to nothing to skip.
• freestream_vel_column_name: name of the freestream velocity column in the file. Set to nothing to skip.
• azimuth_column_name: name of the azimuth column in the file. Set to nothing to skip.
• omega_column_name: name of the omega (rotation rate) Set to nothing to skip.
• pitch_fmt: Format for finding all pitch columns in the file. Should be a regex with a capture group named blade for the blade index, or nothing to skip.
• axial_loading_fmt: Format for finding all axial loading columns in the file. Should be a regex with a captures groups named blade and radial for the blade and radial indices, or nothing to skip.
• circum_loading_fmt: Format for finding all radial loading columns in the file. Should be a regex with a captures groups named blade and radial for the blade and radial indices, or nothing to skip.
• radial_interp_method: <:AbstractRadialInterpMethod indicating method used to interpolate loading from blade element "interfaces" to midpoints.
• time_deriv_method: <:AbstractTimeDerivMethod indicating the method used to calculate the loading time derivatives.
• average_freestream_vel=false: Store possibily unsteady freestream velocity in the OpenFASTData object if false, store average value otherwise.
• average_omega=false: Store possibily unsteady omega (rotation rate) in the OpenFASTData object if false, store average value otherwise.

source_time(se::AbstractCompactSourceElement)

Return the source time of se.

speed_of_sound(se::AbstractCompactSourceElement)

Return the ambient speed of sound associated with se.

tblte_source_elements_ccblade(rotor::CCBlade.Rotor, sections::Vector{CCBlade.Section}, ops::Vector{CCBlade.OperatingPoint}, outputs::Vector{CCBlade.Outputs}, bls::Vector{AbstractBoundaryLayer}, period, num_src_times, positive_x_rotation)

Construct and return an array of TBLTESourceElement objects from CCBlade structs.

Arguments

• rotor: CCBlade rotor object.
• sections: Vector of CCBlade section object.
• ops: Vector of CCBlade operating point.
• outputs: Vector of CCBlade output objects.
• bls::Vector of boundary layer AbstractBoundaryLayer structs.
• period: length of the source time over which the returned source elements will evaluated.
• num_src_times: number of source times.
• positive_x_rotation: rotate blade around the positive-x axis if true, negative-x axis otherwise.

tebvs_source_elements_ccblade(rotor::CCBlade.Rotor, sections::Vector{CCBlade.Section}, ops::Vector{CCBlade.OperatingPoint}, outputs::Vector{CCBlade.Outputs}, hs, Psis, bls::Vector{AbstractBoundaryLayer}, period, num_src_times, positive_x_rotation)

Construct and return an array of TEBVSSourceElement objects from CCBlade structs.

Arguments

• rotor: CCBlade rotor object.
• sections: Vector of CCBlade section object.
• ops: Vector of CCBlade operating point.
• outputs: Vector of CCBlade output objects.
• hs: Vector of trailing edge thicknesses
• Psis: Vector of solid angles between the blade surfaces immediately upstream of the trailing edge (rad)
• bls::Vector of boundary layer AbstractBoundaryLayer structs.
• period: length of the source time over which the returned source elements will evaluated.
• num_src_times: number of source times.
• positive_x_rotation: rotate blade around the positive-x axis if true, negative-x axis otherwise.

tip_vortex_source_elements_ccblade(rotor::CCBlade.Rotor, section::CCBlade.Section, op::CCBlade.OperatingPoint, output::CCBlade.Outputs, bl::AbstractBoundaryLayer, blade_tip::AbstractBladeTip, period, num_src_times, positive_x_rotation)

Construct and return an array of TipVortexSourceElement objects from CCBlade structs.

Note that unlike the other *_source_elements_ccblade functions, tip_vortex_source_elements_ccblade expects scalar arguments instead of vectors for section, op, etc. as a blade only has one tip.

Arguments

• rotor: CCBlade rotor object.
• section: CCBlade section object at the blade tip.
• op: CCBlade operating point object at the blade tip.
• output: CCBlade output object at the blade tip.
• Δr: radial spacing.
• bl:: Boundary layer struct at the blade tip.
• blade_tip: AcousticAnalogies.AbstractBladeTip
• period: length of the source time over which the returned source elements will evaluated.
• num_src_times: number of source times.
• positive_x_rotation: rotate blade around the positive-x axis if true, negative-x axis otherwise.

to_paraview_collection(name::AbstractString, ses::AbstractArray{<:AbstractCompactSourceElement}; time_axis::Integer=1)

Construct and write out a ParaView collection data file (.pvd) object for an array of AbstractCompactSourceElements with name name.pvd (i.e., the name argument should not contain a file extension).

time_axis indicates the timeaxis of ses over which the source time for the source elements in ses vary. One VTK PolyData (.vtp) file will be written for each valid index along `timeaxis`.

Returns a list of filenames written out by WriteVTK.jl.

to_vtp(name::AbstractString, ses::AbstractArray{<:AbstractCompactSourceElement}; kwargs...)

Construct and return a VTK polygonal (.vtp) data file object for an array of AbstractCompactSourceElement with name name.vtp (i.e., the name argument should not contain a file extension).

kwargs are passed to WriteVTK.vtk_grid.

velocity(se::AbstractCompactSourceElement)

Return the current velocity of se.

velocity(t_obs, obs::ConstVelocityAcousticObserver)

Return the velocity of obs at time t_obs (hint—will always be the same)

velocity(t_obs, obs::StationaryAcousticObserver)

Return the velocity of obs at time t_obs (hint—will always be zero ☺)