def noise_airframe_Fink(config, analyses, noise_segment,ioprint = 0, filename=0):
""" SUAVE.Methods.Noise.Fidelity_One.noise_fidelity_one(config, analyses, noise_segment):
Computes the noise from different sources of the airframe for a given vehicle for a constant altitude flight.
Inputs:
vehicle - SUAVE type vehicle
includes these fields:
S - Wing Area
bw - Wing Span
Sht - Horizontal tail area
bht - Horizontal tail span
Svt - Vertical tail area
bvt - Vertical tail span
deltaf - Flap deflection
Sf - Flap area
cf - Flap chord
slots - Number of slots (Flap type)
Dp - Main landing gear tyre diameter
Hp - Main lading gear strut length
Dn - Nose landing gear tyre diameter
Hn - Nose landing gear strut length
wheels - Number of wheels
airport - SUAVE type airport data, with followig fields:
atmosphere - Airport atmosphere (SUAVE type)
altitude - Airport altitude
delta_isa - ISA Temperature deviation
noise segment - flight path data, containing:
distance_vector - distance from the source location to observer
angle - polar angle from the source to the observer
phi - azimuthal angle from the source to the observer
Outputs: One Third Octave Band SPL [dB]
SPL_wing - Sound Pressure Level of the clean wing
SPLht - Sound Pressure Level of the horizontal tail
SPLvt - Sound Pressure Level of the vertical tail
SPL_flap - Sound Pressure Level of the flaps trailing edge
SPL_slat - Sound Pressure Level of the slat leading edge
SPL_main_landing_gear - Sound Pressure Level og the main landing gear
SPL_nose_landing_gear - Sound Pressure Level of the nose landing gear
Assumptions:
Correlation based."""
# ==============================================
# Unpack
# ==============================================
wing = config.wings
Sw = wing.main_wing.areas.reference / (Units.ft)**2 #wing area, sq.ft
bw = wing.main_wing.spans.projected / Units.ft #wing span, ft
Sht = wing.horizontal_stabilizer.areas.reference / (Units.ft)**2 #horizontal tail area, sq.ft
bht = wing.horizontal_stabilizer.spans.projected / Units.ft #horizontal tail span, ft
Svt = wing.vertical_stabilizer.areas.reference / (Units.ft)**2 #vertical tail area, sq.ft
bvt = wing.vertical_stabilizer.spans.projected / Units.ft #vertical tail span, ft
deltaf = wing.main_wing.flaps.angle #flap delection, rad
Sf = wing.main_wing.flaps.area / (Units.ft)**2 #flap area, sq.ft
cf = wing.main_wing.flaps.chord_dimensional / Units.ft #flap chord, ft
Dp = config.landing_gear.main_tire_diameter / Units.ft #MLG tyre diameter, ft
Hp = config.landing_gear.nose_tire_diameter / Units.ft #MLG strut length, ft
Dn = config.landing_gear.main_strut_length / Units.ft #NLG tyre diameter, ft
Hn = config.landing_gear.nose_strut_length / Units.ft #NLG strut length, ft
gear = config.landing_gear.gear_condition #Gear up or gear down
nose_wheels = config.landing_gear.nose_wheels #Number of wheels
main_wheels = config.landing_gear.main_wheels #Number of wheels
main_units = config.landing_gear.main_units #Number of main units
velocity = np.float(noise_segment.conditions.freestream.velocity[0,0]) #aircraft velocity
altitude = noise_segment.conditions.freestream.altitude[:,0] #aircraft altitude
time = noise_segment.conditions.frames.inertial.time[:,0] #time discretization
noise_time = np.arange(0.,time[-1],.5)
altitude = np.interp(noise_time,time,altitude)
# determining flap slot number
if wing.main_wing.flaps.type == 'single_slotted':
slots = 1
elif wing.main_wing.flaps.type == 'double_slotted':
slots = 2
elif wing.main_wing.flaps.type == 'triple_slotted':
slots = 3
# Geometric information from the source to observer position
distance_vector = noise_segment.dist
angle = noise_segment.theta
phi = noise_segment.phi
distance_vector = np.interp(noise_time,time,distance_vector)
angle = np.interp(noise_time,time,angle)
phi = np.interp(noise_time,time,phi)
# Number of points on the discretize segment
nsteps=len(noise_time)
# Preparing matrix for noise calculation
sound_speed = np.zeros(nsteps)
density = np.zeros(nsteps)
viscosity = np.zeros(nsteps)
temperature = np.zeros(nsteps)
M = np.zeros(nsteps)
deltaw = np.zeros(nsteps)
# ==============================================
# Computing atmospheric conditions
# ==============================================
for id in range (0,nsteps):
atmo_data = analyses.atmosphere.compute_values(altitude[id])
#unpack
sound_speed[id] = np.float(atmo_data.speed_of_sound)
density[id] = np.float(atmo_data.density)
viscosity[id] = np.float(atmo_data.dynamic_viscosity*10.7639) #units converstion - m2 to ft2
temperature[id] = np.float(atmo_data.temperature)
#Mach number
M[id] = velocity/np.sqrt(1.4*287*temperature[id])
#Wing Turbulent Boundary Layer thickness, ft
deltaw[id] = 0.37*(Sw/bw)*((velocity/Units.ft)*Sw/(bw*viscosity[id]))**(-0.2)
#Units conversion - knots to ft/s
kt2fts = 1.6878098571
#Generate array with the One Third Octave Band Center Frequencies
frequency = np.array((50, 63, 80, 100, 125, 160, 200, 250, 315, 400, 500, 630, 800, 1000, 1250, 1600, \
2000, 2500, 3150, 4000, 5000, 6300, 8000, 10000))
# Velocity in fts
velocity_fst = velocity * Units.knot
#number of positions of the aircraft to calculate the noise
nrange = len(angle)
i=0
SPL_wing_history = np.zeros((nrange,24))
SPLht_history = np.zeros((nrange,24))
SPLvt_history = np.zeros((nrange,24))
SPL_flap_history = np.zeros((nrange,24))
SPL_slat_history = np.zeros((nrange,24))
SPL_main_landing_gear_history = np.zeros((nrange,24))
SPL_nose_landing_gear_history = np.zeros((nrange,24))
SPL_total_history = np.zeros((nrange,24))
#Noise history in dBA
SPLt_dBA_history = np.zeros((nrange,24))
SPLt_dBA_max = np.zeros(nrange)
#START LOOP FOR EACH POSITION OF AIRCRAFT
for i in range(0,nrange-1):
#Emission angle theta
theta = angle[i]
#Distance from airplane to observer, evaluated at retarded time
distance = distance_vector[i]
#Atmospheric attenuation
delta_atmo=atmospheric_attenuation(distance)
#Call each noise source model
SPL_wing = noise_clean_wing(Sw,bw,0,1,deltaw[i],velocity,viscosity[i],M[i],phi[i],theta,distance,frequency) - delta_atmo #Wing Noise
SPLht = noise_clean_wing(Sht,bht,0,1,deltaw[i],velocity,viscosity[i],M[i],phi[i],theta,distance,frequency) -delta_atmo #Horizontal Tail Noise
SPLvt = noise_clean_wing(Svt,bvt,0,0,deltaw[i],velocity,viscosity[i],M[i],phi[i],theta,distance,frequency) -delta_atmo #Vertical Tail Noise
SPL_slat = noise_leading_edge_slat(SPL_wing,Sw,bw,velocity,deltaw[i],viscosity[i],M[i],phi[i],theta,distance,frequency) -delta_atmo #Slat leading edge
if (deltaf==0):
SPL_flap = np.zeros(24)
else:
SPL_flap = noise_trailing_edge_flap(Sf,cf,deltaf,slots,velocity,M[i],phi[i],theta,distance,frequency) - delta_atmo #Trailing Edge Flaps Noise
if gear=='up': #0
SPL_main_landing_gear = np.zeros(24)
SPL_nose_landing_gear = np.zeros(24)
else:
SPL_main_landing_gear = noise_landing_gear(Dp,Hp,main_wheels,M[i],velocity,phi[i],theta,distance,frequency) - delta_atmo #Main Landing Gear Noise
SPL_nose_landing_gear = noise_landing_gear(Dn,Hn,nose_wheels,M[i],velocity,phi[i],theta,distance,frequency) - delta_atmo #Nose Landing Gear Noise
if main_units>1: #Incoherent summation of each main landing gear unit
SPL_main_landing_gear = SPL_main_landing_gear+3*(main_units-1)
#Total Airframe Noise
SPL_total = 10.*np.log10(10.0**(0.1*SPL_wing)+10.0**(0.1*SPLht)+10**(0.1*SPL_flap)+ \
10.0**(0.1*SPL_slat)+10.0**(0.1*SPL_main_landing_gear)+10.0**(0.1*SPL_nose_landing_gear))
SPL_total_history[i][:] = SPL_total[:]
SPL_wing_history[i][:] = SPL_wing[:]
SPLvt_history[i][:] = SPLvt[:]
SPLht_history[i][:] = SPLht[:]
SPL_flap_history[i][:] = SPL_flap[:]
SPL_slat_history[i][:] = SPL_slat[:]
SPL_nose_landing_gear_history[i][:] = SPL_nose_landing_gear[:]
SPL_main_landing_gear_history[i][:] = SPL_main_landing_gear[:]
#Calculation of dBA based on the sound pressure time history
SPLt_dBA = dbA_noise(SPL_total)
SPLt_dBA_history[i][:] = SPLt_dBA[:]
SPLt_dBA_max[i] = max(SPLt_dBA)
#Calculation of dBA based on the sound pressure time history
dbA_total = np.max(SPLt_dBA_history) #(Not used to certification point)
#Calculation of the Perceived Noise Level EPNL based on the sound time history
PNL_total = pnl_noise(SPL_total_history)
PNL_wing = pnl_noise(SPL_wing_history)
PNL_ht = pnl_noise(SPLht_history)
PNL_vt = pnl_noise(SPLvt_history)
PNL_nose_landing_gear = pnl_noise(SPL_nose_landing_gear_history)
PNL_main_landing_gear = pnl_noise(SPL_main_landing_gear_history)
PNL_slat = pnl_noise(SPL_slat_history)
PNL_flap = pnl_noise(SPL_flap_history)
#Calculation of the tones corrections on the SPL for each component and total
tone_correction_total = noise_tone_correction(SPL_total_history)
tone_correction_wing = noise_tone_correction(SPL_wing_history)
tone_correction_ht = noise_tone_correction(SPLht_history)
tone_correction_vt = noise_tone_correction(SPLvt_history)
tone_correction_flap = noise_tone_correction(SPL_flap_history)
tone_correction_slat = noise_tone_correction(SPL_slat_history)
tone_correction_nose_landing_gear = noise_tone_correction(SPL_nose_landing_gear_history)
tone_correction_main_landing_gear = noise_tone_correction(SPL_main_landing_gear_history)
#Calculation of the PLNT for each component and total
PNLT_total = PNL_total+tone_correction_total
PNLT_wing = PNL_wing+tone_correction_wing
PNLT_ht = PNL_ht+tone_correction_ht
PNLT_vt = PNL_vt+tone_correction_vt
PNLT_nose_landing_gear = PNL_nose_landing_gear+tone_correction_nose_landing_gear
PNLT_main_landing_gear = PNL_main_landing_gear+tone_correction_main_landing_gear
PNLT_slat = PNL_slat+tone_correction_slat
PNLT_flap = PNL_flap+tone_correction_flap
#Calculation of the EPNL for each component and total
EPNL_total = epnl_noise(PNLT_total)
EPNL_wing = epnl_noise(PNLT_wing)
EPNL_ht = epnl_noise(PNLT_ht)
EPNL_vt = epnl_noise(PNLT_vt)
EPNL_nose_landing_gear = epnl_noise(PNLT_nose_landing_gear)
EPNL_main_landing_gear = epnl_noise(PNLT_main_landing_gear)
EPNL_slat = epnl_noise(PNLT_slat)
EPNL_flap = epnl_noise(PNLT_flap)
#Calculation of the SENEL total
SENEL_total = senel_noise(SPLt_dBA_max)
if ioprint:
# write header of file
if not filename:
filename = ('Noise_' + str(config.tag) + '.dat')
fid = open(filename,'w') # Open output file
fid.write('Reference speed = ')
fid.write(str('%2.2f' % (velocity/Units.kts))+' kts')
fid.write('\n')
fid.write('PNLT history')
fid.write('\n')
fid.write('time altitude Mach Polar_angle Azim_angle distance wing ht vt flap slat nose main total dBA')
fid.write('\n')
for id in range (0,nsteps):
fid.write(str('%2.2f' % time[id])+' ')
fid.write(str('%2.2f' % altitude[id])+' ')
fid.write(str('%2.2f' % M[id])+' ')
fid.write(str('%2.2f' % (angle[id]*180/np.pi))+' ')
fid.write(str('%2.2f' % (phi[id]*180/np.pi))+' ')
fid.write(str('%2.2f' % distance_vector[id])+' ')
fid.write(str('%2.2f' % PNLT_wing[id])+' ')
fid.write(str('%2.2f' % PNLT_ht[id])+' ')
fid.write(str('%2.2f' % PNLT_vt[id])+' ')
fid.write(str('%2.2f' % PNLT_flap[id])+' ')
fid.write(str('%2.2f' % PNLT_slat[id])+' ')
fid.write(str('%2.2f' % PNLT_nose_landing_gear[id])+' ')
fid.write(str('%2.2f' % PNLT_main_landing_gear[id])+' ')
fid.write(str('%2.2f' % PNLT_total[id])+' ')
fid.write(str('%2.2f' % SPLt_dBA_max[id])+' ')
fid.write('\n')
fid.write('\n')
fid.write('PNLT max = ')
fid.write(str('%2.2f' % (np.max(PNLT_total)))+' dB')
fid.write('\n')
fid.write('dBA max = ')
fid.write(str('%2.2f' % (np.max(SPLt_dBA_max)))+' dBA')
fid.write('\n')
fid.write('\n')
fid.write('EPNdB')
fid.write('\n')
fid.write('wing ht vt flap slat nose main total')
fid.write('\n')
fid.write(str('%2.2f' % EPNL_wing)+' ')
fid.write(str('%2.2f' % EPNL_ht)+' ')
fid.write(str('%2.2f' % EPNL_vt)+' ')
fid.write(str('%2.2f' % EPNL_flap)+' ')
fid.write(str('%2.2f' % EPNL_slat)+' ')
fid.write(str('%2.2f' % EPNL_nose_landing_gear)+' ')
fid.write(str('%2.2f' % EPNL_main_landing_gear)+' ')
fid.write(str('%2.2f' % EPNL_total)+' ')
fid.write('\n')
fid.write('SENEL = ')
fid.write(str('%2.2f' % SENEL_total)+' ')
fid.close
filename1 = ('History_Noise_' + str(config.tag) + '.dat')
fid = open(filename1,'w') # Open output file
fid.write('Reference speed = ')
fid.write(str('%2.2f' % (velocity/Units.kts))+' kts')
fid.write('\n')
fid.write('Sound Pressure Level for the Total Aircraft Noise')
fid.write('\n')
for nid in range (0,nrange):
fid.write('Polar angle = ' + str('%2.2f' % (angle[nid]*(180/np.pi))) + ' degrees' + '\n')
fid.write('f total SPL(dB) total SPL(dBA)' + '\n')
for id in range(0,24):
fid.write(str((frequency[id])) + ' ')
fid.write(str('%3.2f' % SPL_total_history[nid][id]) + ' ')
fid.write(str('%3.2f' % SPLt_dBA_history[nid][id]))
fid.write('\n')
fid.write('SPLmax (dB) = ')
fid.write(str('%3.2f' % (np.max(SPL_total_history[nid][:])))+' dB' + '\n')
fid.write('SPLmax (dBA) = ')
fid.write(str('%3.2f' % (np.max(SPLt_dBA_history[nid][:])))+' dB')
fid.write('\n')
fid.close
return (EPNL_total,SPL_total_history,SENEL_total)
def noise_SAE(turbofan,
noise_segment,
config,
analyses,
ioprint=0,
filename=0):
#SAE ARP*876D 1994
"""This method predicts the free-field 1/3 Octave Band SPL of coaxial subsonic
jets for turbofan engines under the following conditions:
a) Flyover (observer on ground)
b) Static (observer on ground)
c) In-flight or in-flow (observer on airplane or in a wind tunnel)
Inputs:
vehicle - SUAVE type vehicle
includes these fields:
Velocity_primary - Primary jet flow velocity
Temperature_primary - Primary jet flow temperature
Pressure_primary - Primary jet flow pressure
Area_primary - Area of the primary nozzle
Velocity_secondary - Secondary jet flow velocity
Temperature_secondary - Secondary jet flow temperature
Pressure_secondary - Secondary jet flow pressure
Area_secondary - Area of the secondary nozzle
AOA - Angle of attack
Velocity_aircraft - Aircraft velocity
Altitude - Altitude
N1 - Fan rotational speed [rpm]
EXA - Distance from fan face to fan exit/ fan diameter
Plug_diameter - Diameter of the engine external plug [m]
Engine_height - Engine centerline height above the ground plane
distance_microphone - Distance from the nozzle exhaust to the microphones
angles - Array containing the desired polar angles
airport - SUAVE type airport data, with followig fields:
atmosphere - Airport atmosphere (SUAVE type)
altitude - Airport altitude
delta_isa - ISA Temperature deviation
Outputs: One Third Octave Band SPL [dB]
SPL_p - Sound Pressure Level of the primary jet
SPL_s - Sound Pressure Level of the secondary jet
SPL_m - Sound Pressure Level of the mixed jet
SPL_total - Sound Pressure Level of the total jet noise
Assumptions:
."""
#unpack
Velocity_primary_1 = np.float(turbofan.core_nozzle.noise_speed * 0.92 *
(turbofan.design_thrust / 52700.))
Temperature_primary = noise_segment.conditions.propulsion.acoustic_outputs.core.exit_stagnation_temperature[:,
0]
Pressure_primary = noise_segment.conditions.propulsion.acoustic_outputs.core.exit_stagnation_pressure[:,
0]
Velocity_secondary_1 = np.float(turbofan.fan_nozzle.noise_speed *
(turbofan.design_thrust / 52700.))
Temperature_secondary = noise_segment.conditions.propulsion.acoustic_outputs.fan.exit_stagnation_temperature[:,
0]
Pressure_secondary = noise_segment.conditions.propulsion.acoustic_outputs.fan.exit_stagnation_pressure[:,
0]
N1 = np.float(turbofan.fan.rotation * 0.92 *
(turbofan.design_thrust / 52700.))
Diameter_primary = turbofan.core_nozzle_diameter
Diameter_secondary = turbofan.fan_nozzle_diameter
engine_height = turbofan.engine_height
EXA = turbofan.exa
Plug_diameter = turbofan.plug_diameter
Xe = turbofan.geometry_xe
Ye = turbofan.geometry_ye
Ce = turbofan.geometry_Ce
Velocity_aircraft = np.float(
noise_segment.conditions.freestream.velocity[0, 0])
Altitude = noise_segment.conditions.freestream.altitude[:, 0]
AOA = np.mean(noise_segment.conditions.aerodynamics.angle_of_attack /
Units.deg)
time = noise_segment.conditions.frames.inertial.time[:, 0]
noise_time = np.arange(0., time[-1], .5)
Temperature_primary = np.interp(noise_time, time, Temperature_primary)
Pressure_primary = np.interp(noise_time, time, Pressure_primary)
Temperature_secondary = np.interp(noise_time, time, Temperature_secondary)
Pressure_secondary = np.interp(noise_time, time, Pressure_secondary)
Altitude = np.interp(noise_time, time, Altitude)
# Calls the function noise_geometric to calculate all the distance and emission angles
# geometric = noise_counterplot(noise_segment,analyses,config) #noise_geometric(noise_segment,analyses,config)
#unpack
distance_microphone = noise_segment.dist #geometric[:][0]
angles = noise_segment.theta #geometric[:][1]
phi = noise_segment.phi #geometric[:][2]
distance_microphone = np.interp(noise_time, time, distance_microphone)
angles = np.interp(noise_time, time, angles)
phi = np.interp(noise_time, time, phi)
nsteps = len(noise_time)
#Preparing matrix for noise calculation
sound_ambient = np.zeros(nsteps)
density_ambient = np.zeros(nsteps)
viscosity = np.zeros(nsteps)
temperature_ambient = np.zeros(nsteps)
pressure_amb = np.zeros(nsteps)
Mach_aircraft = np.zeros(nsteps)
Velocity_primary = np.ones(nsteps) * Velocity_primary_1
Velocity_secondary = np.ones(nsteps) * Velocity_secondary_1
# ==============================================
# Computing atmospheric conditions
# ==============================================
for id in range(0, nsteps):
atmo_data = analyses.atmosphere.compute_values(Altitude[id])
sound_ambient[id] = np.float(atmo_data.speed_of_sound)
density_ambient[id] = np.float(atmo_data.density)
viscosity[id] = np.float(atmo_data.dynamic_viscosity)
temperature_ambient[id] = np.float(atmo_data.temperature)
pressure_amb[id] = np.float(atmo_data.pressure)
#Base parameters necessary input for the noise code
pressure_isa = 101325 #[Pa]
R_gas = 287.1 #[J/kg K]
gama_primary = 1.37 #Corretion for the primary jet
gama = 1.4
#Calculation of nozzle areas
Area_primary = np.pi * (Diameter_primary / 2)**2
Area_secondary = np.pi * (Diameter_secondary / 2)**2
Xo = 0 #Acoustic center of reference [m] - Used for wind tunnel acoustic data
#Flags for definition of near-fiel or wind-tunnel data
near_field = 0
tunnel = 0
"""Starting the main program"""
#Arrays for the calculation of atmospheric attenuation
Acq = np.array((0, 0, 0, 0.1, 0.1, 0.1, 0.1, 0.1, 0.2, 0.2, 0.3, 0.4, 0.5,
0.6, 0.7, 0.9, 1.2, 1.5, 1.9, 2.5, 2.9, 3.6, 4.9, 6.8))
Acf = np.array((0, 0, 0, 0, 0.1, 0.1, 0.1, 0.1, 0.1, 0.2, 0.2, 0.3, 0.4,
0.5, 0.6, 0.8, 1.0, 1.3, 1.8, 2.5, 3.0, 4.2, 6.1, 9.0))
#Desired frequency range for noise evaluation
frequency = np.array((50, 63, 80, 100, 125, 160, 200, 250, 315, 400, 500, 630, 800, 1000, 1250, 1600, \
2000, 2500, 3150, 4000, 5000, 6300, 8000, 10000))
#Defining each array before the main loop
B = np.zeros(24)
theta_p = np.ones(24) * np.pi / 2
theta_s = np.ones(24) * np.pi / 2
theta_m = np.ones(24) * np.pi / 2
EX_p = np.zeros(24)
EX_s = np.zeros(24)
EX_m = np.zeros(24)
exc = np.zeros(24)
SPL_p = np.zeros(24)
SPL_s = np.zeros(24)
SPL_m = np.zeros(24)
PG_p = np.zeros(24)
PG_s = np.zeros(24)
PG_m = np.zeros(24)
dspl_attenuation_p = np.zeros(24)
dspl_attenuation_s = np.zeros(24)
dspl_attenuation_m = np.zeros(24)
SPL_total_history = np.zeros((nsteps, 24))
SPL_primary_history = np.zeros((nsteps, 24))
SPL_secondary_history = np.zeros((nsteps, 24))
SPL_mixed_history = np.zeros((nsteps, 24))
#Noise history in dBA
SPLt_dBA_history = np.zeros((nsteps, 24))
SPLt_dBA_max = np.zeros(nsteps)
# Open output file to print the results
if ioprint:
if not filename:
filename = ('SAE_Noise_' + str(config.tag) + '.dat')
fid = open(filename, 'w')
#START LOOP FOR EACH POSITION OF AIRCRAFT
for id in range(0, nsteps):
# Jet Flow Parameters
#Primary and Secondary jets
Cpp = R_gas / (1 - 1 / gama_primary)
Cp = R_gas / (1 - 1 / gama)
density_primary = Pressure_primary[id] / (
R_gas * Temperature_primary[id] -
(0.5 * R_gas * Velocity_primary[id]**2 / Cpp))
density_secondary = Pressure_secondary[id] / (
R_gas * Temperature_secondary[id] -
(0.5 * R_gas * Velocity_secondary[id]**2 / Cp))
mass_flow_primary = Area_primary * Velocity_primary[
id] * density_primary
mass_flow_secondary = Area_secondary * Velocity_secondary[
id] * density_secondary
#Mach number of the external flow - based on the aircraft velocity
Mach_aircraft[id] = Velocity_aircraft / sound_ambient[id]
#Calculation Procedure for the Mixed Jet Flow Parameters
Velocity_mixed = (mass_flow_primary*Velocity_primary[id]+mass_flow_secondary*Velocity_secondary[id])/ \
(mass_flow_primary+mass_flow_secondary)
Temperature_mixed =(mass_flow_primary*Temperature_primary[id]+mass_flow_secondary*Temperature_secondary[id])/ \
(mass_flow_primary+mass_flow_secondary)
density_mixed = pressure_amb[id] / (
R_gas * Temperature_mixed - (0.5 * R_gas * Velocity_mixed**2 / Cp))
Area_mixed = Area_primary*density_primary*Velocity_primary[id]*(1+(mass_flow_secondary/mass_flow_primary))/ \
(density_mixed*Velocity_mixed)
Diameter_mixed = (4 * Area_mixed / np.pi)**0.5
#**********************************************
# START OF THE NOISE PROCEDURE CALCULATIONS
#**********************************************
XBPR = mass_flow_secondary / mass_flow_primary - 5.5
if XBPR < 0:
XBPR = 0
elif XBPR > 4:
XBPR = 4
#Auxiliary parameter defined as DVPS
DVPS = np.abs(
(Velocity_primary[id] - (Velocity_secondary[id] * Area_secondary +
Velocity_aircraft * Area_primary) /
(Area_secondary + Area_primary)))
if DVPS < 0.3:
DVPS = 0.3
# Calculation of the Strouhal number for each jet component (p-primary, s-secondary, m-mixed)
Str_p = frequency * Diameter_primary / (DVPS) #Primary jet
Str_s = frequency * Diameter_mixed / (
Velocity_secondary[id] - Velocity_aircraft) #Secondary jet
Str_m = frequency * Diameter_mixed / (
Velocity_mixed - Velocity_aircraft) #Mixed jet
#Calculation of the Excitation adjustment parameter
#Excitation Strouhal Number
excitation_Strouhal = (N1 / 60) * (Diameter_mixed / Velocity_mixed)
if (excitation_Strouhal > 0.25 and excitation_Strouhal < 0.5):
SX = 0.0
else:
SX = 50 * (excitation_Strouhal - 0.25) * (excitation_Strouhal -
0.5)
#Effectiveness
exps = np.exp(-SX)
#Spectral Shape Factor
exs = 5 * exps * np.exp(
-(np.log10(Str_m / (2 * excitation_Strouhal + 0.00001)))**2)
#Fan Duct Lenght Factor
exd = np.exp(0.6 - (EXA)**0.5)
#Excitation source location factor (zk)
zk = 1 - 0.4 * (exd) * (exps)
#Main loop for the desired polar angles
theta = angles[id]
#Call function noise source location for the calculation of theta
thetaj = noise_source_location(
B, Xo, zk, Diameter_primary, theta_p, Area_primary, Area_secondary,
distance_microphone[id], Diameter_secondary, theta, theta_s,
theta_m, Diameter_mixed, Velocity_primary[id],
Velocity_secondary[id], Velocity_mixed, Velocity_aircraft,
sound_ambient[id], Str_m, Str_s)
# Loop for the frequency array range
for i in range(0, 24):
#Calculation of the Directivity Factor
if (theta_m[i] <= 1.4):
exc[i] = sound_ambient[id] / Velocity_mixed
elif (theta_m[i] > 1.4):
exc[i] = (sound_ambient[id] /
Velocity_mixed) * (1 - (1.8 / np.pi) *
(theta_m[i] - 1.4))
#Acoustic excitation adjustment (EX)
EX_m[i] = exd * exs[i] * exc[
i] #mixed component - dependant of the frequency
EX_p = +5 * exd * exps #primary component - no frequency dependance
EX_s = 2 * sound_ambient[id] / (
Velocity_secondary[id] *
(zk)) #secondary component - no frequency dependance
distance_primary = distance_microphone[id]
distance_secondary = distance_microphone[id]
distance_mixed = distance_microphone[id]
#Noise attenuation due to Ambient Pressure
dspl_ambient_pressure = 20 * np.log10(pressure_amb[id] / pressure_isa)
#Noise attenuation due to Density Gradientes
dspl_density_p = 20 * np.log10(
(density_primary + density_secondary) / (2 * density_ambient[id]))
dspl_density_s = 20 * np.log10(
(density_secondary + density_ambient[id]) /
(2 * density_ambient[id]))
dspl_density_m = 20 * np.log10(
(density_mixed + density_ambient[id]) / (2 * density_ambient[id]))
#Noise attenuation due to Spherical divergence
dspl_spherical_p = 20 * np.log10(Diameter_primary / distance_primary)
dspl_spherical_s = 20 * np.log10(Diameter_mixed / distance_secondary)
dspl_spherical_m = 20 * np.log10(Diameter_mixed / distance_mixed)
#Noise attenuation due to Geometric Near-Field
if near_field == 0:
dspl_geometric_p = 0.0
dspl_geometric_s = 0.0
dspl_geometric_m = 0.0
elif near_field == 1:
dspl_geometric_p = -10 * np.log10(
1 + (2 * Diameter_primary +
(Diameter_primary * sound_ambient[id] / frequency)) /
distance_primary)
dspl_geometric_s = -10 * np.log10(
1 + (2 * Diameter_mixed +
(Diameter_mixed * sound_ambient[id] / frequency)) /
distance_secondary)
dspl_geometric_m = -10 * np.log10(
1 + (2 * Diameter_mixed +
(Diameter_mixed * sound_ambient[id] / frequency)) /
distance_mixed)
#Noise attenuation due to Acoustic Near-Field
if near_field == 0:
dspl_acoustic_p = 0.0
dspl_acoustic_s = 0.0
dspl_acoustic_m = 0.0
elif near_field == 1:
dspl_acoustic_p = 10 * np.log10(
1 + 0.13 * (sound_ambient[id] /
(distance_primary * frequency))**2)
dspl_acoustic_s = 10 * np.log10(
1 + 0.13 * (sound_ambient[id] /
(distance_secondary * frequency))**2)
dspl_acoustic_m = 10 * np.log10(1 + 0.13 *
(sound_ambient[id] /
(distance_mixed * frequency))**2)
#Atmospheric attenuation coefficient
if tunnel == 0:
f_primary = frequency / (1 - Mach_aircraft[id] * np.cos(theta_p))
f_secondary = frequency / (1 - Mach_aircraft[id] * np.cos(theta_s))
f_mixed = frequency / (1 - Mach_aircraft[id] * np.cos(theta_m))
Aci = Acf + ((temperature_ambient[id] - 0) - 15) / 10 * (Acq - Acf)
Ac_primary = np.interp(f_primary, frequency, Aci)
Ac_secondary = np.interp(f_secondary, frequency, Aci)
Ac_mixed = np.interp(f_mixed, frequency, Aci)
#Atmospheric attenuation
delta_atmo = atmospheric_attenuation(distance_primary)
dspl_attenuation_p = -delta_atmo
dspl_attenuation_s = -delta_atmo
dspl_attenuation_m = -delta_atmo
elif tunnel == 1: #These corrections are not applicable for jet rigs or static conditions
dspl_attenuation_p = np.zeros(24)
dspl_attenuation_s = np.zeros(24)
dspl_attenuation_m = np.zeros(24)
EX_m = np.zeros(24)
EX_p = 0
EX_s = 0
#Calculation of the total noise attenuation (p-primary, s-secondary, m-mixed components)
DSPL_p = dspl_ambient_pressure + dspl_density_p + dspl_geometric_p + dspl_acoustic_p + dspl_attenuation_p + dspl_spherical_p
DSPL_s = dspl_ambient_pressure + dspl_density_s + dspl_geometric_s + dspl_acoustic_s + dspl_attenuation_s + dspl_spherical_s
DSPL_m = dspl_ambient_pressure + dspl_density_m + dspl_geometric_m + dspl_acoustic_m + dspl_attenuation_m + dspl_spherical_m
#Calculation of interference effects on jet noise
ATK_m = angle_of_attack_effect(AOA, Mach_aircraft[id], theta_m)
INST_s = jet_installation_effect(Xe, Ye, Ce, theta_s, Diameter_mixed)
Plug = external_plug_effect(Velocity_primary[id],
Velocity_secondary[id], Velocity_mixed,
Diameter_primary, Diameter_secondary,
Diameter_mixed, Plug_diameter,
sound_ambient[id], theta_p, theta_s,
theta_m)
GPROX_m = ground_proximity_effect(Velocity_mixed, sound_ambient[id],
theta_m, engine_height,
Diameter_mixed, frequency)
#Calculation of the sound pressure level for each jet component
SPL_p = primary_noise_component(
SPL_p, Velocity_primary[id], Temperature_primary[id], R_gas,
theta_p, DVPS, sound_ambient[id], Velocity_secondary[id],
Velocity_aircraft, Area_primary, Area_secondary, DSPL_p, EX_p,
Str_p) + Plug[0]
SPL_s = secondary_noise_component(
SPL_s, Velocity_primary[id], theta_s, sound_ambient[id],
Velocity_secondary[id], Velocity_aircraft, Area_primary,
Area_secondary, DSPL_s, EX_s, Str_s) + Plug[1] + INST_s
SPL_m = mixed_noise_component(
SPL_m, Velocity_primary[id], theta_m, sound_ambient[id],
Velocity_secondary[id], Velocity_aircraft, Area_primary,
Area_secondary, DSPL_m, EX_m, Str_m, Velocity_mixed,
XBPR) + Plug[2] + ATK_m + GPROX_m
#Sum of the Total Noise
SPL_total = 10 * np.log10(10**(0.1 * SPL_p) + 10**(0.1 * SPL_s) +
10**(0.1 * SPL_m))
#Store the SPL history
SPL_total_history[id][:] = SPL_total[:]
SPL_primary_history[id][:] = SPL_p[:]
SPL_secondary_history[id][:] = SPL_s[:]
SPL_mixed_history[id][:] = SPL_m[:]
#Calculation of dBA based on the sound pressure time history
SPLt_dBA = dbA_noise(SPL_total)
SPLt_dBA_history[i][:] = SPLt_dBA[:]
SPLt_dBA_max[i] = max(SPLt_dBA)
#Calculation of the Perceived Noise Level EPNL based on the sound time history
PNL_total = pnl_noise(SPL_total_history)
PNL_primary = pnl_noise(SPL_primary_history)
PNL_secondary = pnl_noise(SPL_secondary_history)
PNL_mixed = pnl_noise(SPL_mixed_history)
#Calculation of the tones corrections on the SPL for each component and total
tone_correction_total = noise_tone_correction(SPL_total_history)
tone_correction_primary = noise_tone_correction(SPL_primary_history)
tone_correction_secondary = noise_tone_correction(SPL_secondary_history)
tone_correction_mixed = noise_tone_correction(SPL_mixed_history)
#Calculation of the PLNT for each component and total
PNLT_total = PNL_total + tone_correction_total
PNLT_primary = PNL_primary + tone_correction_primary
PNLT_secondary = PNL_secondary + tone_correction_secondary
PNLT_mixed = PNL_mixed + tone_correction_mixed
#Calculation of the EPNL for each component and total
EPNL_total = epnl_noise(PNLT_total)
EPNL_primary = epnl_noise(PNLT_primary)
EPNL_secondary = epnl_noise(PNLT_secondary)
EPNL_mixed = epnl_noise(PNLT_mixed)
#Calculation of the SENEL total
SENEL_total = senel_noise(SPLt_dBA_max)
if ioprint:
# print EPNL_total
#Printing the output solution for the engine noise calculation
fid.write('Engine noise module - SAE Model for Turbofan' + '\n')
fid.write('Certification point = FLYOVER' + '\n')
fid.write('EPNL = ' + str('%3.2f' % EPNL_total) + '\n')
fid.write('PNLTM = ' + str('%3.2f' % np.max(PNLT_total)) + '\n')
fid.write('Reference speed = ')
fid.write(str('%2.2f' % (Velocity_aircraft / Units.kts)) + ' kts')
fid.write('\n')
fid.write('PNLT history')
fid.write('\n')
fid.write(
'time altitude Mach Core Velocity Fan Velocity Polar angle Azim angle distance Primary Secondary Mixed Total'
)
fid.write('\n')
for id in range(0, nsteps):
fid.write(str('%2.2f' % time[id]) + ' ')
fid.write(str('%2.2f' % Altitude[id]) + ' ')
fid.write(str('%2.2f' % Mach_aircraft[id]) + ' ')
fid.write(str('%3.3f' % Velocity_primary[id]) + ' ')
fid.write(str('%3.3f' % Velocity_secondary[id]) + ' ')
fid.write(str('%2.2f' % (angles[id] * 180 / np.pi)) + ' ')
fid.write(str('%2.2f' % (phi[id] * 180 / np.pi)) + ' ')
fid.write(str('%2.2f' % distance_microphone[id]) + ' ')
fid.write(str('%2.2f' % PNLT_primary[id]) + ' ')
fid.write(str('%2.2f' % PNLT_secondary[id]) + ' ')
fid.write(str('%2.2f' % PNLT_mixed[id]) + ' ')
fid.write(str('%2.2f' % PNLT_total[id]) + ' ')
fid.write(str('%2.2f' % SPLt_dBA_max[id]) + ' ')
fid.write('\n')
fid.write('\n')
fid.write('PNLT max = ')
fid.write(str('%2.2f' % (np.max(PNLT_total))) + ' dB')
fid.write('\n')
fid.write('dBA max = ')
fid.write(str('%2.2f' % (np.max(SPLt_dBA_max))) + ' dBA')
fid.write('\n')
fid.write('EPNdB')
fid.write('\n')
fid.write('Primary Secondary Mixed Total')
fid.write('\n')
fid.write(str('%2.2f' % EPNL_primary) + ' ')
fid.write(str('%2.2f' % EPNL_secondary) + ' ')
fid.write(str('%2.2f' % EPNL_mixed) + ' ')
fid.write(str('%2.2f' % EPNL_total) + ' ')
fid.write('\n')
fid.write('\n')
fid.write('SENEL = ')
fid.write(str('%2.2f' % SENEL_total) + ' ')
for id in range(0, nsteps):
fid.write('\n')
fid.write('\n')
fid.write('Emission angle = ' + str(angles[id] * 180 / np.pi) +
'\n')
fid.write('Altitude = ' + str(Altitude[id]) + '\n')
fid.write('Distance = ' + str(distance_microphone[id]) + '\n')
fid.write('Time = ' + str(time[id]) + '\n')
fid.write('f Primary Secondary Mixed Total' + '\n')
for ijd in range(0, 24):
fid.write(str((frequency[ijd])) + ' ')
fid.write(
str('%3.2f' % SPL_primary_history[id][ijd]) + ' ')
fid.write(
str('%3.2f' % SPL_secondary_history[id][ijd]) + ' ')
fid.write(
str('%3.2f' % SPL_mixed_history[id][ijd]) + ' ')
fid.write(
str('%3.2f' % SPL_total_history[id][ijd]) + ' ')
fid.write('\n')
fid.close
return (EPNL_total, SPL_total_history, SENEL_total)
def noise_airframe_Fink(segment,
analyses,
config,
settings,
ioprint=0,
filename=0):
""" This computes the noise from different sources of the airframe for a given vehicle for a constant altitude flight.
Assumptions:
Correlation based
Source:
Fink, Martin R. Airframe noise prediction method. No. UTRC/R77-912607-11. UNITED
TECHNOLOGIES RESEARCH CENTER EAST HARTFORD CT, 1977.
Inputs:
vehicle - SUAVE type vehicle
includes these fields:
S - Wing Area
bw - Wing Span
Sht - Horizontal tail area
bht - Horizontal tail span
Svt - Vertical tail area
bvt - Vertical tail span
deltaf - Flap deflection
Sf - Flap area
cf - Flap chord
slots - Number of slots (Flap type)
Dp - Main landing gear tyre diameter
Hp - Main lading gear strut length
Dn - Nose landing gear tyre diameter
Hn - Nose landing gear strut length
wheels - Number of wheels
airport - SUAVE type airport data, with followig fields:
atmosphere - Airport atmosphere (SUAVE type)
altitude - Airport altitude
delta_isa - ISA Temperature deviation
noise segment - flight path data, containing:
distance_vector - distance from the source location to observer
angle - polar angle from the source to the observer
phi - azimuthal angle from the source to the observer
Outputs: One Third Octave Band SPL [dB]
SPL_wing - Sound Pressure Level of the clean wing
SPLht - Sound Pressure Level of the horizontal tail
SPLvt - Sound Pressure Level of the vertical tail
SPL_flap - Sound Pressure Level of the flaps trailing edge
SPL_slat - Sound Pressure Level of the slat leading edge
SPL_main_landing_gear - Sound Pressure Level og the main landing gear
SPL_nose_landing_gear - Sound Pressure Level of the nose landing gear
Properties Used:
N/A
"""
# Unpack
wing = config.wings
flap = wing.main_wing.control_surfaces.flap
Sw = wing.main_wing.areas.reference / (Units.ft)**2 # wing area, sq.ft
bw = wing.main_wing.spans.projected / Units.ft # wing span, ft
Sht = wing.horizontal_stabilizer.areas.reference / (
Units.ft)**2 # horizontal tail area, sq.ft
bht = wing.horizontal_stabilizer.spans.projected / Units.ft # horizontal tail span, ft
Svt = wing.vertical_stabilizer.areas.reference / (
Units.ft)**2 # vertical tail area, sq.ft
bvt = wing.vertical_stabilizer.spans.projected / Units.ft # vertical tail span, ft
deltaf = flap.deflection # flap delection, rad
Sf = flap.area / (Units.ft)**2 # flap area, sq.ft
cf = flap.chord_dimensional / Units.ft # flap chord, ft
Dp = config.landing_gear.main_tire_diameter / Units.ft # MLG tyre diameter, ft
Hp = config.landing_gear.nose_tire_diameter / Units.ft # MLG strut length, ft
Dn = config.landing_gear.main_strut_length / Units.ft # NLG tyre diameter, ft
Hn = config.landing_gear.nose_strut_length / Units.ft # NLG strut length, ft
gear = config.landing_gear.gear_condition # Gear up or gear down
nose_wheels = config.landing_gear.nose_wheels # Number of wheels
main_wheels = config.landing_gear.main_wheels # Number of wheels
main_units = config.landing_gear.main_units # Number of main units
velocity = np.float(
segment.conditions.freestream.velocity[0, 0]) # aircraft velocity
altitude = segment.conditions.freestream.altitude[:,
0] # aircraft altitude
noise_time = segment.conditions.frames.inertial.time[:,
0] # time discretization
# determining flap slot number
if wing.main_wing.control_surfaces.flap.configuration_type == 'single_slotted':
slots = 1
elif wing.main_wing.control_surfaces.flap.configuration_type == 'double_slotted':
slots = 2
elif wing.main_wing.control_surfaces.flap.configuration_type == 'triple_slotted':
slots = 3
# Geometric information from the source to observer position
distance_vector = segment.dist
angle = segment.theta
phi = segment.phi
# Number of points on the discretize segment
nsteps = len(noise_time)
# Computing atmospheric conditions
sound_speed = segment.conditions.freestream.speed_of_sound[:, 0]
viscosity = segment.conditions.freestream.dynamic_viscosity[:,
0] * Units.ft * Units.ft # units converstion - m2 to ft2
M = velocity / sound_speed
#Wing Turbulent Boundary Layer thickness, ft
deltaw = 0.37 * (Sw / bw) * ((velocity / Units.ft) * Sw /
(bw * viscosity))**(-0.2)
#Generate array with the One Third Octave Band Center Frequencies
frequency = settings.center_frequencies[5:]
num_f = len(frequency)
# number of positions of the aircraft to calculate the noise
nrange = len(angle)
SPL_wing_history = np.zeros((nrange, num_f))
SPLht_history = np.zeros((nrange, num_f))
SPLvt_history = np.zeros((nrange, num_f))
SPL_flap_history = np.zeros((nrange, num_f))
SPL_slat_history = np.zeros((nrange, num_f))
SPL_main_landing_gear_history = np.zeros((nrange, num_f))
SPL_nose_landing_gear_history = np.zeros((nrange, num_f))
SPL_total_history = np.zeros((nrange, num_f))
# Noise history in dBA
SPLt_dBA_history = np.zeros((nrange, num_f))
SPLt_dBA_max = np.zeros(nrange)
#START LOOP FOR EACH POSITION OF AIRCRAFT
for i in range(nrange - 1):
# Emission angle theta
theta = angle[i]
# Distance from airplane to observer, evaluated at retarded time
distance = distance_vector[i]
# Atmospheric attenuation
delta_atmo = atmospheric_attenuation(distance)
# Call each noise source model
SPL_wing = noise_clean_wing(
Sw, bw, 0, 1, deltaw[i], velocity, viscosity[i], M[i], phi[i],
theta, distance, frequency) - delta_atmo #Wing Noise
SPLht = noise_clean_wing(
Sht, bht, 0, 1, deltaw[i], velocity, viscosity[i], M[i], phi[i],
theta, distance, frequency) - delta_atmo #Horizontal Tail Noise
SPLvt = noise_clean_wing(Svt, bvt, 0, 0, deltaw[i], velocity,
viscosity[i], M[i], phi[i], theta, distance,
frequency) - delta_atmo #Vertical Tail Noise
SPL_slat = noise_leading_edge_slat(
SPL_wing, Sw, bw, velocity, deltaw[i], viscosity[i], M[i], phi[i],
theta, distance, frequency) - delta_atmo #Slat leading edge
if (deltaf == 0):
SPL_flap = np.zeros(num_f)
else:
SPL_flap = noise_trailing_edge_flap(
Sf, cf, deltaf, slots, velocity, M[i], phi[i], theta, distance,
frequency) - delta_atmo #Trailing Edge Flaps Noise
if gear == 'up': #0
SPL_main_landing_gear = np.zeros(num_f)
SPL_nose_landing_gear = np.zeros(num_f)
else:
SPL_main_landing_gear = noise_landing_gear(
Dp, Hp, main_wheels, M[i], velocity, phi[i], theta, distance,
frequency) - delta_atmo #Main Landing Gear Noise
SPL_nose_landing_gear = noise_landing_gear(
Dn, Hn, nose_wheels, M[i], velocity, phi[i], theta, distance,
frequency) - delta_atmo #Nose Landing Gear Noise
if main_units > 1: # Incoherent summation of each main landing gear unit
SPL_main_landing_gear = SPL_main_landing_gear + 3 * (main_units -
1)
# Total Airframe Noise
SPL_total = 10.*np.log10(10.0**(0.1*SPL_wing)+10.0**(0.1*SPLht)+10**(0.1*SPL_flap)+ \
10.0**(0.1*SPL_slat)+10.0**(0.1*SPL_main_landing_gear)+10.0**(0.1*SPL_nose_landing_gear))
SPL_total_history[i][:] = SPL_total[:]
SPL_wing_history[i][:] = SPL_wing[:]
SPLvt_history[i][:] = SPLvt[:]
SPLht_history[i][:] = SPLht[:]
SPL_flap_history[i][:] = SPL_flap[:]
SPL_slat_history[i][:] = SPL_slat[:]
SPL_nose_landing_gear_history[i][:] = SPL_nose_landing_gear[:]
SPL_main_landing_gear_history[i][:] = SPL_main_landing_gear[:]
# Calculation of dBA based on the sound pressure time history
SPLt_dBA = dbA_noise(SPL_total)
SPLt_dBA_history[i][:] = SPLt_dBA[:]
SPLt_dBA_max[i] = max(SPLt_dBA)
# Calculation of the Perceived Noise Level EPNL based on the sound time history
PNL_total = pnl_noise(SPL_total_history)
PNL_wing = pnl_noise(SPL_wing_history)
PNL_ht = pnl_noise(SPLht_history)
PNL_vt = pnl_noise(SPLvt_history)
PNL_nose_landing_gear = pnl_noise(SPL_nose_landing_gear_history)
PNL_main_landing_gear = pnl_noise(SPL_main_landing_gear_history)
PNL_slat = pnl_noise(SPL_slat_history)
PNL_flap = pnl_noise(SPL_flap_history)
# Calculation of the tones corrections on the SPL for each component and total
tone_correction_total = noise_tone_correction(SPL_total_history)
tone_correction_wing = noise_tone_correction(SPL_wing_history)
tone_correction_ht = noise_tone_correction(SPLht_history)
tone_correction_vt = noise_tone_correction(SPLvt_history)
tone_correction_flap = noise_tone_correction(SPL_flap_history)
tone_correction_slat = noise_tone_correction(SPL_slat_history)
tone_correction_nose_landing_gear = noise_tone_correction(
SPL_nose_landing_gear_history)
tone_correction_main_landing_gear = noise_tone_correction(
SPL_main_landing_gear_history)
# Calculation of the PLNT for each component and total
PNLT_total = PNL_total + tone_correction_total
PNLT_wing = PNL_wing + tone_correction_wing
PNLT_ht = PNL_ht + tone_correction_ht
PNLT_vt = PNL_vt + tone_correction_vt
PNLT_nose_landing_gear = PNL_nose_landing_gear + tone_correction_nose_landing_gear
PNLT_main_landing_gear = PNL_main_landing_gear + tone_correction_main_landing_gear
PNLT_slat = PNL_slat + tone_correction_slat
PNLT_flap = PNL_flap + tone_correction_flap
#Calculation of the EPNL for each component and total
EPNL_total = epnl_noise(PNLT_total)
EPNL_wing = epnl_noise(PNLT_wing)
EPNL_ht = epnl_noise(PNLT_ht)
EPNL_vt = epnl_noise(PNLT_vt)
EPNL_nose_landing_gear = epnl_noise(PNLT_nose_landing_gear)
EPNL_main_landing_gear = epnl_noise(PNLT_main_landing_gear)
EPNL_slat = epnl_noise(PNLT_slat)
EPNL_flap = epnl_noise(PNLT_flap)
#Calculation of the SENEL total
SENEL_total = senel_noise(SPLt_dBA_max)
SAE_Airframe_Noise_Outputs = Data(
tag=config.tag,
filename=filename,
velocity=velocity,
nsteps=nsteps,
time=noise_time,
altitude=altitude,
M=M,
angle=angle,
distance_vector=distance_vector,
PNLT_wing=PNLT_wing,
phi=phi,
PNLT_ht=PNLT_ht,
PNLT_vt=PNLT_vt,
PNLT_flap=PNLT_flap,
PNLT_slat=PNLT_slat,
PNLT_nose_landing_gear=PNLT_nose_landing_gear,
PNLT_main_landing_gear=PNLT_main_landing_gear,
PNLT_total=PNLT_total,
SPLt_dBA_max=SPLt_dBA_max,
nrange=nrange,
frequency=frequency,
EPNL_wing=EPNL_wing,
EPNL_ht=EPNL_ht,
EPNL_vt=EPNL_vt,
EPNL_flap=EPNL_flap,
EPNL_slat=EPNL_slat,
EPNL_nose_landing_gear=EPNL_nose_landing_gear,
EPNL_main_landing_gear=EPNL_main_landing_gear,
EPNL_total=EPNL_total,
SENEL_total=SENEL_total,
SPL_total_history=SPL_total_history,
SPLt_dBA_history=SPLt_dBA_history)
if ioprint:
print_airframe_output(SAE_Airframe_Noise_Outputs)
# Pack Airframe Noise
airframe_noise = Data()
airframe_noise.EPNL_total = EPNL_total
airframe_noise.SPL = SPL_arithmetic(SPL_total_history, sum_axis=1)
airframe_noise.SPL_spectrum = SPL_total_history
airframe_noise.SPL_dBA = SPL_arithmetic(np.atleast_2d(SPLt_dBA),
sum_axis=1)
airframe_noise.SENEL_total = SENEL_total
airframe_noise.noise_time = noise_time
return airframe_noise
def noise_SAE(turbofan,
segment,
analyses,
config,
settings,
ioprint=0,
filename=0):
"""This method predicts the free-field 1/3 Octave Band SPL of coaxial subsonic
jets for turbofan engines under the following conditions:
a) Flyover (observer on ground)
b) Static (observer on ground)
c) In-flight or in-flow (observer on airplane or in a wind tunnel)
Assumptions:
SAE ARP876D: Gas Turbine Jet Exhaust Noise Prediction
Inputs:
vehicle - SUAVE type vehicle
includes these fields:
Velocity_primary - Primary jet flow velocity [m/s]
Temperature_primary - Primary jet flow temperature [m/s]
Pressure_primary - Primary jet flow pressure [Pa]
Area_primary - Area of the primary nozzle [m^2]
Velocity_secondary - Secondary jet flow velocity [m/s]
Temperature_secondary - Secondary jet flow temperature [m/s]
Pressure_secondary - Secondary jet flow pressure [Pa]
Area_secondary - Area of the secondary nozzle [m^2]
AOA - Angle of attack [rad]
Velocity_aircraft - Aircraft velocity [m/s]
Altitude - Altitude [m]
N1 - Fan rotational speed [rpm]
EXA - Distance from fan face to fan exit/ fan diameter [m]
Plug_diameter - Diameter of the engine external plug [m]
Engine_height - Engine centerline height above the ground plane [m]
distance_microphone - Distance from the nozzle exhaust to the microphones [m]
angles - Array containing the desired polar angles [rad]
airport - SUAVE type airport data, with followig fields:
atmosphere - Airport atmosphere (SUAVE type)
altitude - Airport altitude
delta_isa - ISA Temperature deviation
Outputs: One Third Octave Band SPL [dB]
SPL_p - Sound Pressure Level of the primary jet [dB]
SPL_s - Sound Pressure Level of the secondary jet [dB]
SPL_m - Sound Pressure Level of the mixed jet [dB]
SPL_total - Sound Pressure Level of the total jet noise [dB]
"""
# unpack
Velocity_primary = turbofan.core_nozzle.noise_speed * 0.92 * (
turbofan.design_thrust / 52700.)
Temperature_primary = segment.conditions.noise.sources.turbofan.core.exit_stagnation_temperature[:,
0]
Pressure_primary = segment.conditions.noise.sources.turbofan.core.exit_stagnation_pressure[:,
0]
Velocity_secondary = turbofan.fan_nozzle.noise_speed * (
turbofan.design_thrust / 52700.)
Temperature_secondary = segment.conditions.noise.sources.turbofan.fan.exit_stagnation_temperature[:,
0]
Pressure_secondary = segment.conditions.noise.sources.turbofan.fan.exit_stagnation_pressure[:,
0]
N1 = turbofan.fan.rotation * 0.92 * (turbofan.design_thrust / 52700.)
Diameter_primary = turbofan.core_nozzle_diameter
Diameter_secondary = turbofan.fan_nozzle_diameter
engine_height = turbofan.engine_height
EXA = turbofan.exa
Plug_diameter = turbofan.plug_diameter
Xe = turbofan.geometry_xe
Ye = turbofan.geometry_ye
Ce = turbofan.geometry_Ce
Velocity_aircraft = np.float(segment.conditions.freestream.velocity[0, 0])
Altitude = segment.conditions.freestream.altitude[:, 0]
AOA = np.mean(segment.conditions.aerodynamics.angle_of_attack / Units.deg)
noise_time = segment.conditions.frames.inertial.time[:, 0]
# unpack
distance_microphone = segment.dist
angles = segment.theta
phi = segment.phi
nsteps = len(noise_time)
#Preparing matrix for noise calculation
sound_ambient = np.zeros(nsteps)
density_ambient = np.zeros(nsteps)
viscosity = np.zeros(nsteps)
temperature_ambient = np.zeros(nsteps)
pressure_amb = np.zeros(nsteps)
Mach_aircraft = np.zeros(nsteps)
if type(Velocity_primary) == float:
Velocity_primary = np.ones(nsteps) * Velocity_primary
if type(Velocity_secondary) == float:
Velocity_secondary = np.ones(nsteps) * Velocity_secondary
# ==============================================
# Computing atmospheric conditions
# ==============================================
sound_ambient = segment.conditions.freestream.speed_of_sound[:, 0]
density_ambient = segment.conditions.freestream.density[:, 0]
viscosity = segment.conditions.freestream.dynamic_viscosity[:, 0]
temperature_ambient = segment.conditions.freestream.temperature[:, 0]
pressure_amb = segment.conditions.freestream.pressure[:, 0]
#Base parameters necessary input for the noise code
pressure_isa = 101325 # [Pa]
R_gas = 287.1 # [J/kg K]
gamma_primary = 1.37 # Corretion for the primary jet
gamma = 1.4
#Calculation of nozzle areas
Area_primary = np.pi * (Diameter_primary / 2)**2
Area_secondary = np.pi * (Diameter_secondary / 2)**2
Xo = 0 # Acoustic center of reference [m] - Used for wind tunnel acoustic data
# Flags for definition of near-fiel or wind-tunnel data
near_field = 0
tunnel = 0
"""Starting the main program"""
#Arrays for the calculation of atmospheric attenuation
Acq = np.array((0, 0, 0, 0.1, 0.1, 0.1, 0.1, 0.1, 0.2, 0.2, 0.3, 0.4, 0.5,
0.6, 0.7, 0.9, 1.2, 1.5, 1.9, 2.5, 2.9, 3.6, 4.9, 6.8))
Acf = np.array((0, 0, 0, 0, 0.1, 0.1, 0.1, 0.1, 0.1, 0.2, 0.2, 0.3, 0.4,
0.5, 0.6, 0.8, 1.0, 1.3, 1.8, 2.5, 3.0, 4.2, 6.1, 9.0))
#Desired frequency range for noise evaluation
frequency = settings.center_frequencies[5:]
num_f = len(frequency)
# Defining each array before the main loop
B = np.zeros(num_f)
theta_p = np.ones(num_f) * np.pi / 2
theta_s = np.ones(num_f) * np.pi / 2
theta_m = np.ones(num_f) * np.pi / 2
EX_p = np.zeros(num_f)
EX_s = np.zeros(num_f)
EX_m = np.zeros(num_f)
exc = np.zeros(num_f)
SPL_p = np.zeros(num_f)
SPL_s = np.zeros(num_f)
SPL_m = np.zeros(num_f)
PG_p = np.zeros(num_f)
PG_s = np.zeros(num_f)
PG_m = np.zeros(num_f)
dspl_attenuation_p = np.zeros(num_f)
dspl_attenuation_s = np.zeros(num_f)
dspl_attenuation_m = np.zeros(num_f)
SPL_total_history = np.zeros((nsteps, num_f))
SPL_primary_history = np.zeros((nsteps, num_f))
SPL_secondary_history = np.zeros((nsteps, num_f))
SPL_mixed_history = np.zeros((nsteps, num_f))
# Noise history in dBA
SPLt_dBA = np.zeros((nsteps, num_f))
SPLt_dBA_history = np.zeros((nsteps, num_f))
SPLt_dBA_max = np.zeros(nsteps)
# Start loop for each position of aircraft
for id in range(0, nsteps):
# Jet Flow Parameters
#Primary and Secondary jets
Cpp = R_gas / (1 - 1 / gamma_primary)
Cp = R_gas / (1 - 1 / gamma)
density_primary = Pressure_primary[id] / (
R_gas * Temperature_primary[id] -
(0.5 * R_gas * Velocity_primary[id]**2 / Cpp))
density_secondary = Pressure_secondary[id] / (
R_gas * Temperature_secondary[id] -
(0.5 * R_gas * Velocity_secondary[id]**2 / Cp))
mass_flow_primary = Area_primary * Velocity_primary[
id] * density_primary
mass_flow_secondary = Area_secondary * Velocity_secondary[
id] * density_secondary
#Mach number of the external flow - based on the aircraft velocity
Mach_aircraft[id] = Velocity_aircraft / sound_ambient[id]
#Calculation Procedure for the Mixed Jet Flow Parameters
Velocity_mixed = (mass_flow_primary*Velocity_primary[id]+mass_flow_secondary*Velocity_secondary[id])/ \
(mass_flow_primary+mass_flow_secondary)
Temperature_mixed =(mass_flow_primary*Temperature_primary[id]+mass_flow_secondary*Temperature_secondary[id])/ \
(mass_flow_primary+mass_flow_secondary)
density_mixed = pressure_amb[id] / (
R_gas * Temperature_mixed - (0.5 * R_gas * Velocity_mixed**2 / Cp))
Area_mixed = Area_primary*density_primary*Velocity_primary[id]*(1+(mass_flow_secondary/mass_flow_primary))/ \
(density_mixed*Velocity_mixed)
Diameter_mixed = (4 * Area_mixed / np.pi)**0.5
#**********************************************
# START OF THE NOISE PROCEDURE CALCULATIONS
#**********************************************
XBPR = mass_flow_secondary / mass_flow_primary - 5.5
if XBPR < 0:
XBPR = 0
elif XBPR > 4:
XBPR = 4
#Auxiliary parameter defined as DVPS
DVPS = np.abs((Velocity_primary[id] - (Velocity_secondary[id]*Area_secondary+Velocity_aircraft*Area_primary)/\
(Area_secondary+Area_primary)))
if DVPS < 0.3:
DVPS = 0.3
# Calculation of the Strouhal number for each jet component (p-primary, s-secondary, m-mixed)
Str_p = frequency * Diameter_primary / (DVPS) #Primary jet
Str_s = frequency * Diameter_mixed / (
Velocity_secondary[id] - Velocity_aircraft) #Secondary jet
Str_m = frequency * Diameter_mixed / (
Velocity_mixed - Velocity_aircraft) #Mixed jet
#Calculation of the Excitation adjustment parameter
#Excitation Strouhal Number
excitation_Strouhal = (N1 / 60) * (Diameter_mixed / Velocity_mixed)
if (excitation_Strouhal > 0.25 and excitation_Strouhal < 0.5):
SX = 0.0
else:
SX = 50 * (excitation_Strouhal - 0.25) * (excitation_Strouhal -
0.5)
#Effectiveness
exps = np.exp(-SX)
#Spectral Shape Factor
exs = 5 * exps * np.exp(
-(np.log10(Str_m / (2 * excitation_Strouhal + 0.00001)))**2)
#Fan Duct Lenght Factor
exd = np.exp(0.6 - (EXA)**0.5)
#Excitation source location factor (zk)
zk = 1 - 0.4 * (exd) * (exps)
#Main loop for the desired polar angles
theta = angles[id]
# Call function noise source location for the calculation of theta
thetaj = noise_source_location(
B, Xo, zk, Diameter_primary, theta_p, Area_primary, Area_secondary,
distance_microphone[id], Diameter_secondary, theta, theta_s,
theta_m, Diameter_mixed, Velocity_primary[id],
Velocity_secondary[id], Velocity_mixed, Velocity_aircraft,
sound_ambient[id], Str_m, Str_s)
# Loop for the frequency array range
for i in range(0, num_f):
#Calculation of the Directivity Factor
if (theta_m[i] <= 1.4):
exc[i] = sound_ambient[id] / Velocity_mixed
elif (theta_m[i] > 1.4):
exc[i] = (sound_ambient[id] /
Velocity_mixed) * (1 - (1.8 / np.pi) *
(theta_m[i] - 1.4))
#Acoustic excitation adjustment (EX)
EX_m[i] = exd * exs[i] * exc[
i] #mixed component - dependant of the frequency
EX_p = +5 * exd * exps #primary component - no frequency dependance
EX_s = 2 * sound_ambient[id] / (
Velocity_secondary[id] *
(zk)) #secondary component - no frequency dependance
distance_primary = distance_microphone[id]
distance_secondary = distance_microphone[id]
distance_mixed = distance_microphone[id]
#Noise attenuation due to Ambient Pressure
dspl_ambient_pressure = 20 * np.log10(pressure_amb[id] / pressure_isa)
#Noise attenuation due to Density Gradientes
dspl_density_p = 20 * np.log10(
(density_primary + density_secondary) / (2 * density_ambient[id]))
dspl_density_s = 20 * np.log10(
(density_secondary + density_ambient[id]) /
(2 * density_ambient[id]))
dspl_density_m = 20 * np.log10(
(density_mixed + density_ambient[id]) / (2 * density_ambient[id]))
#Noise attenuation due to Spherical divergence
dspl_spherical_p = 20 * np.log10(Diameter_primary / distance_primary)
dspl_spherical_s = 20 * np.log10(Diameter_mixed / distance_secondary)
dspl_spherical_m = 20 * np.log10(Diameter_mixed / distance_mixed)
# Noise attenuation due to Geometric Near-Field
if near_field == 0:
dspl_geometric_p = 0.0
dspl_geometric_s = 0.0
dspl_geometric_m = 0.0
elif near_field == 1:
dspl_geometric_p = -10 * np.log10(
1 + (2 * Diameter_primary +
(Diameter_primary * sound_ambient[id] / frequency)) /
distance_primary)
dspl_geometric_s = -10 * np.log10(
1 + (2 * Diameter_mixed +
(Diameter_mixed * sound_ambient[id] / frequency)) /
distance_secondary)
dspl_geometric_m = -10 * np.log10(
1 + (2 * Diameter_mixed +
(Diameter_mixed * sound_ambient[id] / frequency)) /
distance_mixed)
# Noise attenuation due to Acoustic Near-Field
if near_field == 0:
dspl_acoustic_p = 0.0
dspl_acoustic_s = 0.0
dspl_acoustic_m = 0.0
elif near_field == 1:
dspl_acoustic_p = 10 * np.log10(
1 + 0.13 * (sound_ambient[id] /
(distance_primary * frequency))**2)
dspl_acoustic_s = 10 * np.log10(
1 + 0.13 * (sound_ambient[id] /
(distance_secondary * frequency))**2)
dspl_acoustic_m = 10 * np.log10(1 + 0.13 *
(sound_ambient[id] /
(distance_mixed * frequency))**2)
# Atmospheric attenuation coefficient
if tunnel == 0:
f_primary = frequency / (1 - Mach_aircraft[id] * np.cos(theta_p))
f_secondary = frequency / (1 - Mach_aircraft[id] * np.cos(theta_s))
f_mixed = frequency / (1 - Mach_aircraft[id] * np.cos(theta_m))
Aci = Acf + ((temperature_ambient[id] - 0) - 15) / 10 * (Acq - Acf)
Ac_primary = np.interp(f_primary, frequency, Aci)
Ac_secondary = np.interp(f_secondary, frequency, Aci)
Ac_mixed = np.interp(f_mixed, frequency, Aci)
#Atmospheric attenuation
delta_atmo = atmospheric_attenuation(distance_primary)
dspl_attenuation_p = -delta_atmo
dspl_attenuation_s = -delta_atmo
dspl_attenuation_m = -delta_atmo
elif tunnel == 1: #These corrections are not applicable for jet rigs or static conditions
dspl_attenuation_p = np.zeros(num_f)
dspl_attenuation_s = np.zeros(num_f)
dspl_attenuation_m = np.zeros(num_f)
EX_m = np.zeros(num_f)
EX_p = 0
EX_s = 0
# Calculation of the total noise attenuation (p-primary, s-secondary, m-mixed components)
DSPL_p = dspl_ambient_pressure + dspl_density_p + dspl_geometric_p + dspl_acoustic_p + dspl_attenuation_p + dspl_spherical_p
DSPL_s = dspl_ambient_pressure + dspl_density_s + dspl_geometric_s + dspl_acoustic_s + dspl_attenuation_s + dspl_spherical_s
DSPL_m = dspl_ambient_pressure + dspl_density_m + dspl_geometric_m + dspl_acoustic_m + dspl_attenuation_m + dspl_spherical_m
# Calculation of interference effects on jet noise
ATK_m = angle_of_attack_effect(AOA, Mach_aircraft[id], theta_m)
INST_s = jet_installation_effect(Xe, Ye, Ce, theta_s, Diameter_mixed)
Plug = external_plug_effect(Velocity_primary[id],
Velocity_secondary[id], Velocity_mixed,
Diameter_primary, Diameter_secondary,
Diameter_mixed, Plug_diameter,
sound_ambient[id], theta_p, theta_s,
theta_m)
GPROX_m = ground_proximity_effect(Velocity_mixed, sound_ambient[id],
theta_m, engine_height,
Diameter_mixed, frequency)
# Calculation of the sound pressure level for each jet component
SPL_p = primary_noise_component(
SPL_p, Velocity_primary[id], Temperature_primary[id], R_gas,
theta_p, DVPS, sound_ambient[id], Velocity_secondary[id],
Velocity_aircraft, Area_primary, Area_secondary, DSPL_p, EX_p,
Str_p) + Plug.PG_p
SPL_s = secondary_noise_component(
SPL_s, Velocity_primary[id], theta_s, sound_ambient[id],
Velocity_secondary[id], Velocity_aircraft, Area_primary,
Area_secondary, DSPL_s, EX_s, Str_s) + Plug.PG_s + INST_s
SPL_m = mixed_noise_component(SPL_m,Velocity_primary[id],theta_m,sound_ambient[id],Velocity_secondary[id],
Velocity_aircraft,Area_primary,Area_secondary,DSPL_m,EX_m,Str_m,Velocity_mixed,XBPR) + \
Plug.PG_m + ATK_m + GPROX_m
# Sum of the Total Noise
SPL_total = 10 * np.log10(10**(0.1 * SPL_p) + 10**(0.1 * SPL_s) +
10**(0.1 * SPL_m))
# Store the SPL history
SPL_total_history[id][:] = SPL_total[:]
SPL_primary_history[id][:] = SPL_p[:]
SPL_secondary_history[id][:] = SPL_s[:]
SPL_mixed_history[id][:] = SPL_m[:]
# Calculation of dBA based on the sound pressure time history
SPLt_dBA = dbA_noise(SPL_total)
SPLt_dBA_history[id][:] = dbA_noise(SPL_total)
SPLt_dBA_max[id] = max(SPLt_dBA)
# Calculation of the Perceived Noise Level EPNL based on the sound time history
PNL_total = pnl_noise(SPL_total_history)
PNL_primary = pnl_noise(SPL_primary_history)
PNL_secondary = pnl_noise(SPL_secondary_history)
PNL_mixed = pnl_noise(SPL_mixed_history)
# Calculation of the tones corrections on the SPL for each component and total
tone_correction_total = noise_tone_correction(SPL_total_history)
tone_correction_primary = noise_tone_correction(SPL_primary_history)
tone_correction_secondary = noise_tone_correction(SPL_secondary_history)
tone_correction_mixed = noise_tone_correction(SPL_mixed_history)
# Calculation of the PLNT for each component and total
PNLT_total = PNL_total + tone_correction_total
PNLT_primary = PNL_primary + tone_correction_primary
PNLT_secondary = PNL_secondary + tone_correction_secondary
PNLT_mixed = PNL_mixed + tone_correction_mixed
# Calculation of the EPNL for each component and total
EPNL_total = epnl_noise(PNLT_total)
EPNL_primary = epnl_noise(PNLT_primary)
EPNL_secondary = epnl_noise(PNLT_secondary)
EPNL_mixed = epnl_noise(PNLT_mixed)
#Calculation of the SENEL total
SENEL_total = senel_noise(SPLt_dBA_max)
# Open output file to print the results
SAE_Engine_Noise_Outputs = Data(
filename=filename,
tag=config.tag,
EPNL_total=EPNL_total,
PNLT_total=PNLT_total,
Velocity_aircraft=Velocity_aircraft,
noise_time=noise_time,
Altitude=Altitude,
Mach_aircraft=Mach_aircraft,
Velocity_primary=Velocity_primary,
Velocity_secondary=Velocity_secondary,
angles=angles,
phi=phi,
distance_microphone=distance_microphone,
PNLT_primary=PNLT_primary,
PNLT_secondary=PNLT_secondary,
PNLT_mixed=PNLT_mixed,
SPLt_dBA_max=SPLt_dBA_max,
EPNL_primary=EPNL_primary,
EPNL_secondary=EPNL_secondary,
EPNL_mixed=EPNL_mixed,
SENEL_total=SENEL_total,
nsteps=nsteps,
frequency=frequency,
SPL_primary_history=SPL_primary_history,
SPL_secondary_history=SPL_secondary_history,
SPL_mixed_history=SPL_mixed_history,
SPL_total_history=SPL_total_history)
if ioprint:
print_engine_output(SAE_Engine_Noise_Outputs)
engine_noise = Data()
engine_noise.EPNL_total = EPNL_total
engine_noise.SENEL_total = SENEL_total
engine_noise.SPL_spectrum = SPL_total_history
engine_noise.SPL = SPL_arithmetic(SPL_total_history, sum_axis=1)
engine_noise.SPL_dBA = SPLt_dBA_max
return engine_noise
def noise_airframe_Fink(config, analyses, noise_segment,ioprint = 0, filename=0):
""" SUAVE.Methods.Noise.Fidelity_One.noise_fidelity_one(config, analyses, noise_segment):
Computes the noise from different sources of the airframe for a given vehicle for a constant altitude flight.
Inputs:
vehicle - SUAVE type vehicle
includes these fields:
S - Wing Area
bw - Wing Span
Sht - Horizontal tail area
bht - Horizontal tail span
Svt - Vertical tail area
bvt - Vertical tail span
deltaf - Flap deflection
Sf - Flap area
cf - Flap chord
slots - Number of slots (Flap type)
Dp - Main landing gear tyre diameter
Hp - Main lading gear strut length
Dn - Nose landing gear tyre diameter
Hn - Nose landing gear strut length
wheels - Number of wheels
airport - SUAVE type airport data, with followig fields:
atmosphere - Airport atmosphere (SUAVE type)
altitude - Airport altitude
delta_isa - ISA Temperature deviation
noise segment - flight path data, containing:
distance_vector - distance from the source location to observer
angle - polar angle from the source to the observer
phi - azimuthal angle from the source to the observer
Outputs: One Third Octave Band SPL [dB]
SPL_wing - Sound Pressure Level of the clean wing
SPLht - Sound Pressure Level of the horizontal tail
SPLvt - Sound Pressure Level of the vertical tail
SPL_flap - Sound Pressure Level of the flaps trailing edge
SPL_slat - Sound Pressure Level of the slat leading edge
SPL_main_landing_gear - Sound Pressure Level og the main landing gear
SPL_nose_landing_gear - Sound Pressure Level of the nose landing gear
Assumptions:
Correlation based."""
# ==============================================
# Unpack
# ==============================================
wing = config.wings
Sw = wing.main_wing.areas.reference / (Units.ft)**2 #wing area, sq.ft
bw = wing.main_wing.spans.projected / Units.ft #wing span, ft
Sht = wing.horizontal_stabilizer.areas.reference / (Units.ft)**2 #horizontal tail area, sq.ft
bht = wing.horizontal_stabilizer.spans.projected / Units.ft #horizontal tail span, ft
Svt = wing.vertical_stabilizer.areas.reference / (Units.ft)**2 #vertical tail area, sq.ft
bvt = wing.vertical_stabilizer.spans.projected / Units.ft #vertical tail span, ft
deltaf = wing.main_wing.flaps.angle #flap delection, rad
Sf = wing.main_wing.flaps.area / (Units.ft)**2 #flap area, sq.ft
cf = wing.main_wing.flaps.chord_dimensional / Units.ft #flap chord, ft
Dp = config.landing_gear.main_tire_diameter / Units.ft #MLG tyre diameter, ft
Hp = config.landing_gear.nose_tire_diameter / Units.ft #MLG strut length, ft
Dn = config.landing_gear.main_strut_length / Units.ft #NLG tyre diameter, ft
Hn = config.landing_gear.nose_strut_length / Units.ft #NLG strut length, ft
gear = config.landing_gear.gear_condition #Gear up or gear down
nose_wheels = config.landing_gear.nose_wheels #Number of wheels
main_wheels = config.landing_gear.main_wheels #Number of wheels
main_units = config.landing_gear.main_units #Number of main units
velocity = np.float(noise_segment.conditions.freestream.velocity[0,0]) #aircraft velocity
altitude = noise_segment.conditions.freestream.altitude[:,0] #aircraft altitude
time = noise_segment.conditions.frames.inertial.time[:,0] #time discretization
noise_time = np.arange(0.,time[-1],.5)
altitude = np.interp(noise_time,time,altitude)
# determining flap slot number
if wing.main_wing.flaps.type == 'single_slotted':
slots = 1
elif wing.main_wing.flaps.type == 'double_slotted':
slots = 2
elif wing.main_wing.flaps.type == 'triple_slotted':
slots = 3
# Geometric information from the source to observer position
distance_vector = noise_segment.dist
angle = noise_segment.theta
phi = noise_segment.phi
distance_vector = np.interp(noise_time,time,distance_vector)
angle = np.interp(noise_time,time,angle)
phi = np.interp(noise_time,time,phi)
# Number of points on the discretize segment
nsteps=len(noise_time)
# Preparing matrix for noise calculation
sound_speed = np.zeros(nsteps)
density = np.zeros(nsteps)
viscosity = np.zeros(nsteps)
temperature = np.zeros(nsteps)
M = np.zeros(nsteps)
deltaw = np.zeros(nsteps)
# ==============================================
# Computing atmospheric conditions
# ==============================================
for id in range (0,nsteps):
atmo_data = analyses.atmosphere.compute_values(altitude[id])
#unpack
sound_speed[id] = np.float(atmo_data.speed_of_sound)
density[id] = np.float(atmo_data.density)
viscosity[id] = np.float(atmo_data.dynamic_viscosity*10.7639) #units converstion - m2 to ft2
temperature[id] = np.float(atmo_data.temperature)
#Mach number
M[id] = velocity/np.sqrt(1.4*287*temperature[id])
#Wing Turbulent Boundary Layer thickness, ft
deltaw[id] = 0.37*(Sw/bw)*((velocity/Units.ft)*Sw/(bw*viscosity[id]))**(-0.2)
#Units conversion - knots to ft/s
kt2fts = 1.6878098571
#Generate array with the One Third Octave Band Center Frequencies
frequency = np.array((50, 63, 80, 100, 125, 160, 200, 250, 315, 400, 500, 630, 800, 1000, 1250, 1600, \
2000, 2500, 3150, 4000, 5000, 6300, 8000, 10000))
# Velocity in fts
velocity_fst = velocity * Units.knot
#number of positions of the aircraft to calculate the noise
nrange = len(angle)
i=0
SPL_wing_history = np.zeros((nrange,24))
SPLht_history = np.zeros((nrange,24))
SPLvt_history = np.zeros((nrange,24))
SPL_flap_history = np.zeros((nrange,24))
SPL_slat_history = np.zeros((nrange,24))
SPL_main_landing_gear_history = np.zeros((nrange,24))
SPL_nose_landing_gear_history = np.zeros((nrange,24))
SPL_total_history = np.zeros((nrange,24))
#Noise history in dBA
SPLt_dBA_history = np.zeros((nrange,24))
SPLt_dBA_max = np.zeros(nrange)
#START LOOP FOR EACH POSITION OF AIRCRAFT
for i in range(0,nrange-1):
#Emission angle theta
theta = angle[i]
#Distance from airplane to observer, evaluated at retarded time
distance = distance_vector[i]
#Atmospheric attenuation
delta_atmo=atmospheric_attenuation(distance)
#Call each noise source model
SPL_wing = noise_clean_wing(Sw,bw,0,1,deltaw[i],velocity,viscosity[i],M[i],phi[i],theta,distance,frequency) - delta_atmo #Wing Noise
SPLht = noise_clean_wing(Sht,bht,0,1,deltaw[i],velocity,viscosity[i],M[i],phi[i],theta,distance,frequency) -delta_atmo #Horizontal Tail Noise
SPLvt = noise_clean_wing(Svt,bvt,0,0,deltaw[i],velocity,viscosity[i],M[i],phi[i],theta,distance,frequency) -delta_atmo #Vertical Tail Noise
SPL_slat = noise_leading_edge_slat(SPL_wing,Sw,bw,velocity,deltaw[i],viscosity[i],M[i],phi[i],theta,distance,frequency) -delta_atmo #Slat leading edge
if (deltaf==0):
SPL_flap = np.zeros(24)
else:
SPL_flap = noise_trailing_edge_flap(Sf,cf,deltaf,slots,velocity,M[i],phi[i],theta,distance,frequency) - delta_atmo #Trailing Edge Flaps Noise
if gear=='up': #0
SPL_main_landing_gear = np.zeros(24)
SPL_nose_landing_gear = np.zeros(24)
else:
SPL_main_landing_gear = noise_landing_gear(Dp,Hp,main_wheels,M[i],velocity,phi[i],theta,distance,frequency) - delta_atmo #Main Landing Gear Noise
SPL_nose_landing_gear = noise_landing_gear(Dn,Hn,nose_wheels,M[i],velocity,phi[i],theta,distance,frequency) - delta_atmo #Nose Landing Gear Noise
if main_units>1: #Incoherent summation of each main landing gear unit
SPL_main_landing_gear = SPL_main_landing_gear+3*(main_units-1)
#Total Airframe Noise
SPL_total = 10.*np.log10(10.0**(0.1*SPL_wing)+10.0**(0.1*SPLht)+10**(0.1*SPL_flap)+ \
10.0**(0.1*SPL_slat)+10.0**(0.1*SPL_main_landing_gear)+10.0**(0.1*SPL_nose_landing_gear))
SPL_total_history[i][:] = SPL_total[:]
SPL_wing_history[i][:] = SPL_wing[:]
SPLvt_history[i][:] = SPLvt[:]
SPLht_history[i][:] = SPLht[:]
SPL_flap_history[i][:] = SPL_flap[:]
SPL_slat_history[i][:] = SPL_slat[:]
SPL_nose_landing_gear_history[i][:] = SPL_nose_landing_gear[:]
SPL_main_landing_gear_history[i][:] = SPL_main_landing_gear[:]
#Calculation of dBA based on the sound pressure time history
SPLt_dBA = dbA_noise(SPL_total)
SPLt_dBA_history[i][:] = SPLt_dBA[:]
SPLt_dBA_max[i] = max(SPLt_dBA)
#Calculation of dBA based on the sound pressure time history
dbA_total = np.max(SPLt_dBA_history) #(Not used to certification point)
#Calculation of the Perceived Noise Level EPNL based on the sound time history
PNL_total = pnl_noise(SPL_total_history)
PNL_wing = pnl_noise(SPL_wing_history)
PNL_ht = pnl_noise(SPLht_history)
PNL_vt = pnl_noise(SPLvt_history)
PNL_nose_landing_gear = pnl_noise(SPL_nose_landing_gear_history)
PNL_main_landing_gear = pnl_noise(SPL_main_landing_gear_history)
PNL_slat = pnl_noise(SPL_slat_history)
PNL_flap = pnl_noise(SPL_flap_history)
#Calculation of the tones corrections on the SPL for each component and total
tone_correction_total = noise_tone_correction(SPL_total_history)
tone_correction_wing = noise_tone_correction(SPL_wing_history)
tone_correction_ht = noise_tone_correction(SPLht_history)
tone_correction_vt = noise_tone_correction(SPLvt_history)
tone_correction_flap = noise_tone_correction(SPL_flap_history)
tone_correction_slat = noise_tone_correction(SPL_slat_history)
tone_correction_nose_landing_gear = noise_tone_correction(SPL_nose_landing_gear_history)
tone_correction_main_landing_gear = noise_tone_correction(SPL_main_landing_gear_history)
#Calculation of the PLNT for each component and total
PNLT_total = PNL_total+tone_correction_total
PNLT_wing = PNL_wing+tone_correction_wing
PNLT_ht = PNL_ht+tone_correction_ht
PNLT_vt = PNL_vt+tone_correction_vt
PNLT_nose_landing_gear = PNL_nose_landing_gear+tone_correction_nose_landing_gear
PNLT_main_landing_gear = PNL_main_landing_gear+tone_correction_main_landing_gear
PNLT_slat = PNL_slat+tone_correction_slat
PNLT_flap = PNL_flap+tone_correction_flap
#Calculation of the EPNL for each component and total
EPNL_total = epnl_noise(PNLT_total)
EPNL_wing = epnl_noise(PNLT_wing)
EPNL_ht = epnl_noise(PNLT_ht)
EPNL_vt = epnl_noise(PNLT_vt)
EPNL_nose_landing_gear = epnl_noise(PNLT_nose_landing_gear)
EPNL_main_landing_gear = epnl_noise(PNLT_main_landing_gear)
EPNL_slat = epnl_noise(PNLT_slat)
EPNL_flap = epnl_noise(PNLT_flap)
#Calculation of the SENEL total
SENEL_total = senel_noise(SPLt_dBA_max)
if ioprint:
# write header of file
if not filename:
filename = ('Noise_' + str(config.tag) + '.dat')
fid = open(filename,'w') # Open output file
fid.write('Reference speed = ')
fid.write(str('%2.2f' % (velocity/Units.kts))+' kts')
fid.write('\n')
fid.write('PNLT history')
fid.write('\n')
fid.write('time altitude Mach Polar_angle Azim_angle distance wing ht vt flap slat nose main total dBA')
fid.write('\n')
for id in range (0,nsteps):
fid.write(str('%2.2f' % time[id])+' ')
fid.write(str('%2.2f' % altitude[id])+' ')
fid.write(str('%2.2f' % M[id])+' ')
fid.write(str('%2.2f' % (angle[id]*180/np.pi))+' ')
fid.write(str('%2.2f' % (phi[id]*180/np.pi))+' ')
fid.write(str('%2.2f' % distance_vector[id])+' ')
fid.write(str('%2.2f' % PNLT_wing[id])+' ')
fid.write(str('%2.2f' % PNLT_ht[id])+' ')
fid.write(str('%2.2f' % PNLT_vt[id])+' ')
fid.write(str('%2.2f' % PNLT_flap[id])+' ')
fid.write(str('%2.2f' % PNLT_slat[id])+' ')
fid.write(str('%2.2f' % PNLT_nose_landing_gear[id])+' ')
fid.write(str('%2.2f' % PNLT_main_landing_gear[id])+' ')
fid.write(str('%2.2f' % PNLT_total[id])+' ')
fid.write(str('%2.2f' % SPLt_dBA_max[id])+' ')
fid.write('\n')
fid.write('\n')
fid.write('PNLT max = ')
fid.write(str('%2.2f' % (np.max(PNLT_total)))+' dB')
fid.write('\n')
fid.write('dBA max = ')
fid.write(str('%2.2f' % (np.max(SPLt_dBA_max)))+' dBA')
fid.write('\n')
fid.write('\n')
fid.write('EPNdB')
fid.write('\n')
fid.write('wing ht vt flap slat nose main total')
fid.write('\n')
fid.write(str('%2.2f' % EPNL_wing)+' ')
fid.write(str('%2.2f' % EPNL_ht)+' ')
fid.write(str('%2.2f' % EPNL_vt)+' ')
fid.write(str('%2.2f' % EPNL_flap)+' ')
fid.write(str('%2.2f' % EPNL_slat)+' ')
fid.write(str('%2.2f' % EPNL_nose_landing_gear)+' ')
fid.write(str('%2.2f' % EPNL_main_landing_gear)+' ')
fid.write(str('%2.2f' % EPNL_total)+' ')
fid.write('\n')
fid.write('SENEL = ')
fid.write(str('%2.2f' % SENEL_total)+' ')
fid.close
filename1 = ('History_Noise_' + str(config.tag) + '.dat')
fid = open(filename1,'w') # Open output file
fid.write('Reference speed = ')
fid.write(str('%2.2f' % (velocity/Units.kts))+' kts')
fid.write('\n')
fid.write('Sound Pressure Level for the Total Aircraft Noise')
fid.write('\n')
for nid in range (0,nrange):
fid.write('Polar angle = ' + str('%2.2f' % (angle[nid]*(180/np.pi))) + ' degrees' + '\n')
fid.write('f total SPL(dB) total SPL(dBA)' + '\n')
for id in range(0,24):
fid.write(str((frequency[id])) + ' ')
fid.write(str('%3.2f' % SPL_total_history[nid][id]) + ' ')
fid.write(str('%3.2f' % SPLt_dBA_history[nid][id]))
fid.write('\n')
fid.write('SPLmax (dB) = ')
fid.write(str('%3.2f' % (np.max(SPL_total_history[nid][:])))+' dB' + '\n')
fid.write('SPLmax (dBA) = ')
fid.write(str('%3.2f' % (np.max(SPLt_dBA_history[nid][:])))+' dB')
fid.write('\n')
fid.close
return (EPNL_total,SPL_total_history,SENEL_total)