Ir al contenido

Actualizar de la 3.3 a la 4.0

La 4.0 rompe duro y no lleva capa de compatibilidad. Casi nada se ha borrado: de los 885 nombres que la raíz exportaba en la 3.3.0, setenta y ocho no existen ya en ningún sitio y el resto simplemente vive en una dirección con nombre en vez de en una plana. Así que el trabajo es sobre todo un barrido de imports, y esta página es sobre todo un mapa.

Con las dos primeras secciones arreglas los imports. La tercera léela aunque tengas prisa, porque en cuatro sitios, uno de ellos solo para el código escrito contra la 4.0.0rc1, el arreglo evidente es el equivocado, y tres de esos cuatro cambian un número sin levantar nada.

En la 3.3.0 la raíz reexportaba la biblioteca entera, así que from phonometry import laeq funcionaba para casi cualquier nombre. Hoy la raíz exporta veinticinco cosas: los veintiún subpaquetes, las tres clases que no pertenecen a ningún dominio concreto (Signal, ReportMetadata, PhonometryWarning) y __version__.

import phonometry
print(len(phonometry.__all__)) # 25
print("laeq" in phonometry.__all__) # False
from phonometry.signals import laeq # esta es la grafía nueva

Medido sobre la superficie entera, 804 de aquellos 885 nombres de la raíz los publica hoy exactamente un subpaquete, ninguno dos, y ninguno necesita una ruta más profunda que phonometry.<subpaquete>. Otros tres siguen en la raíz, donde siempre estuvieron. Así que el cambio no tiene ambigüedad: busca el subpaquete e importa de él.

La forma de atributo no se retiró nunca, que es el cambio más pequeño posible para el código que tiraba de la raíz:

from phonometry import filters
print(filters.nominal_frequencies(1).labels)

En vez de buscar cada uno en la referencia, pregúntaselo al paquete instalado:

import importlib
import pkgutil
import phonometry
def whereis(name):
"""Cada módulo público que publica `name`, del menos profundo al que más."""
found = ["phonometry"] if name in phonometry.__all__ else []
for attribute in phonometry.__all__:
package = getattr(phonometry, attribute)
if not hasattr(package, "__path__"):
continue
modules = [package.__name__]
modules += [m.name for m in pkgutil.walk_packages(package.__path__, package.__name__ + ".")]
for module_name in modules:
if any(part.startswith("_") for part in module_name.split(".")):
continue
try:
module = importlib.import_module(module_name)
except ImportError:
continue
if name in getattr(module, "__all__", ()):
found.append(module_name)
return sorted(found, key=lambda path: path.count("."))
print(whereis("laeq")[0]) # phonometry.signals
print(whereis("reverberation_time")[0]) # phonometry.room
print(whereis("sensitivity")[0]) # phonometry.metrology
print(whereis("Signal")[0]) # phonometry

Recorre el árbol en unos dos segundos. Cuando devuelve varias rutas, la menos profunda es el import canónico: un subpaquete reexporta lo que publican sus propios módulos, y esa ruta corta es la que usan las guías y los tests. Los cuatro nombres que la raíz sigue publicando por su cuenta, Signal, PhonometryWarning, ReportMetadata y __version__, vuelven como phonometry a secas. Una lista vacía significa que el nombre está en la última sección de esta página.

Cinco de los treinta módulos que cambiaron de ruta no se mudaron a una dirección nueva. Se dividieron, y quien siga sólo la primera mitad de la partición se lleva un ImportError por el resto. Merece la pena revisarlos uno a uno, y el paquete privado de renderizado va con ellos porque le pasó lo mismo:

Módulo en 3.3.0 Dónde está hoy su contenido
phonometry.impedance_tube materials.absorbers.impedance_tube (función de transferencia de dos micrófonos), materials.absorbers.four_microphone (TransferMatrix, transfer_matrix_one_load, wave_decomposition, face_quantities, air_layer_transfer_matrix), materials.absorbers.standing_wave y fluids
phonometry.scattering_diffusion materials.diffusers.reverberation_room_scattering para la parte de cámara reverberante (ScatteringResult, ScatteringUncertainty, BASE_PLATE_BANDS_HZ y el resto), materials.diffusers.scattering_diffusion para los nueve nombres de campo libre
phonometry.materials.porous_absorber materials.absorbers.porous para los modelos de material en masa, materials.absorbers.layered para toda la API multicapa (layered_absorber, AirLayer, MembraneLayer, PerforatedPlateLayer, MicroperforatedPlateLayer, LayeredAbsorberResult)
phonometry.metrology.spectra signals.spectra, más signals.multitaper (multitaper_psd) y signals.windows (window_metrics)
phonometry.compliance filters.compliance (FilterComplianceResult, class_limits, verify_filter_class), filters.weighting_compliance (verify_weighting_class, weighting_class_limits), aircraft.measurement_system (verify_aircraft_noise_system)
phonometry._plotting phonometry._plot.<dominio>: los 82 renderizadores se repartieron por dominio, así que plot_airborne_insulation está en _plot.building y plot_age_threshold en _plot.hearing. Privado en ambos casos, y la vía soportada es el .plot() del resultado

Los otros veinticinco se mudaron enteros, y el resolutor de arriba los encuentra sin leer esta tabla. Cada uno de los tres primeros era alcanzable por dos rutas en la 3.3.0, la plana y la de dentro de su paquete, y las dos han desaparecido.

Cuatro sitios donde el arreglo evidente es el equivocado

Sección titulada «Cuatro sitios donde el arreglo evidente es el equivocado»

Todo lo demás de esta página se anuncia en cuanto lo ejecutas, y el arreglo es el que parece. Estos cuatro no son así.

Los auxiliares del tubo de impedancia tomaban kelvin

Sección titulada «Los auxiliares del tubo de impedancia tomaban kelvin»

air_density_iso y speed_of_sound_iso documentaban y consumían su temperatura en kelvin. Sus sucesores toman grados Celsius, como el resto de la biblioteca. El nombre cambió, así que el import falla y te enteras, pero el problema es el argumento que arrastras: 293,15 es un número de aspecto legítimo en cualquiera de las dos unidades.

from phonometry.materials import speed_of_sound_iso10534
print(round(float(speed_of_sound_iso10534(temperature_c=20.0)), 5)) # 343.28784
print(round(float(speed_of_sound_iso10534(temperature_c=293.15)), 5)) # 477.13003

343,29 m/s frente a 477,13 m/s: un 39 % de error, sin excepción ninguna, y cada coeficiente de absorción calculado a partir de ahí sale mal en una cantidad de aspecto plausible. Convierte el valor, no te limites a renombrar la palabra clave.

3.3.0 4.0
impedance_tube.air_density_iso(T_kelvin, p_kPa) materials.air_density_iso10534(temperature_c=T_kelvin - 273.15, static_pressure_kpa=p_kPa)
impedance_tube.speed_of_sound_iso(T_kelvin) materials.speed_of_sound_iso10534(temperature_c=T_kelvin - 273.15)

Con la conversión aplicada, los dos devuelven exactamente lo que devolvían en la 3.3.0, bit a bit.

noise_control.GasStream guardaba la temperatura de entrada de IEC 60534-8-3 como inlet_temperature_k en la 4.0.0rc1, en kelvin, que es como la lee el apartado 5. En la 4.0 el campo es inlet_temperature_c, en grados Celsius como cualquier otra temperatura que toma la biblioteca, y la conversión a la temperatura absoluta que necesita el apartado 5 se hace dentro. La palabra clave falla, así que lo notarás, pero 450,0 es un número tan legítimo en una unidad como en la otra: renombra la palabra clave, conserva el número y el gas está 273,15 K más caliente. El ejemplo 1 del Anexo A a 450 K da 91,7 dB(A) a 1 m de la tubería; el mismo 450 leído en grados Celsius da 93,0 dB(A), y no salta nada.

4.0.0rc1 4.0
GasStream(inlet_temperature_k=T_kelvin, ...) GasStream(inlet_temperature_c=T_kelvin - 273.15, ...)

speed_of_sound es speed_of_sound_iso17497, no fluids.air()

Sección titulada «speed_of_sound es speed_of_sound_iso17497, no fluids.air()»

El speed_of_sound(temperature) de la 3.3.0, en el primer nivel y en materials.scattering_diffusion, es la fórmula de una línea de la ISO 17497-1, y en la 4.0 es materials.speed_of_sound_iso17497: la misma fórmula y el mismo número, con la temperatura, todavía en grados Celsius, escrita por su nombre. La trampa es el otro candidato. fluids.air() es de donde el resto de la 4.0 lee la velocidad del sonido del aire, así que parece la casa nueva de una función que la devolvía, pero calcula aire húmedo por el Anexo F de IEC 61094-2: a 20 °C responde 343,99 m/s donde la fórmula de la ISO 17497-1 responde 343,20 m/s, y no salta nada. Es poco, y no es nada despreciable si estás reproduciendo una medición hecha con el número antiguo.

from phonometry import fluids, materials
print(round(float(materials.speed_of_sound_iso17497(temperature_c=20.0)), 2)) # 343.2
air = fluids.air(temperature_c=20.0, relative_humidity_percent=50.0, static_pressure_pa=101_325.0)
print(round(air.speed_of_sound, 2)) # 343.99
3.3.0 4.0
speed_of_sound(T_celsius) materials.speed_of_sound_iso17497(temperature_c=T_celsius)

transmission_loss pasó a propagation_loss, cosa que el import detecta, y con él se renombró el campo de dentro del resultado. Ese no levanta nada: un PropagationLossResult no tiene .tl, así que el AttributeError aparece allí donde lo leas, que puede quedar lejos de la llamada.

from phonometry.underwater.propagation.closed_form import propagation_loss
result = propagation_loss([1000.0], 1000.0)
print(round(float(result.pl[0]), 5)) # 60.06013, el número que guardaba .tl

El mismo renombrado llega a underwater.sonar_equation, cuyo parámetro transmission_loss es ahora propagation_loss.

Cinco puntos de entrada ya no toman las condiciones ambientales como números sueltos. Ahí no basta con renombrar la palabra clave, porque el parámetro ha desaparecido del todo:

3.3.0 4.0
airport_noise.event_level(..., temperature=15.0, pressure=101.325) event_level(..., atmosphere=AerodromeAtmosphere(temperature_c=15.0, static_pressure_kpa=101.325))
airport_noise.noise_contour(...) lo mismo, con AerodromeAtmosphere
rotorcraft_noise.rotorcraft_event_level(..., temperature=15.0, relative_humidity=70.0) rotorcraft_event_level(..., atmosphere=RotorcraftAtmosphere(temperature_c=15.0, relative_humidity_percent=70.0))
rotorcraft_noise.rotorcraft_noise_contour(...) lo mismo, con RotorcraftAtmosphere
outdoor_propagation.predicted_receiver_level(..., humidity=70.0) predicted_receiver_level(..., atmosphere=AtmosphericConditions(relative_humidity_percent=70.0))

Las demás opciones de estas funciones también pasaron a registros, entre ellas las sustituciones punto a punto del rotorcraft, y la sección siguiente las recorre.

from phonometry.aircraft.airport_noise import AerodromeAtmosphere
atmosphere = AerodromeAtmosphere(temperature_c=15.0, static_pressure_kpa=101.325)
print(atmosphere.temperature_c, atmosphere.static_pressure_kpa)

Las firmas más largas toman sus opciones en registros

Sección titulada «Las firmas más largas toman sus opciones en registros»

Diez firmas tomaban más de trece parámetros cada una, y en la 4.0 las opciones que van juntas son un registro. Una palabra clave de la 3.3.0 entre ellas no se renombró, sino que desapareció, así que una llamada que la pasa lanza TypeError: construye el registro al que fue la palabra clave y pasa ese. Cada campo de un registro se escribe por su nombre, y un campo con valor por defecto tiene el que tenía su palabra clave, así que un registro lleva solo lo que cambias. Las atmósferas de la sección anterior son registros de la misma clase; estos son los demás:

3.3.0 4.0
filter_type=, ripple= y attenuation= en octave_filter y OctaveFilterBank, y resample= en OctaveFilterBank design=filters.FilterDesign(filter_type=..., ripple=..., attenuation=..., resample=...)
calibration_factor= y dbfs= en octave_filter y OctaveFilterBank calibration=filters.LevelCalibration(factor=..., dbfs=...)
show= y plot_file= en octave_filter y OctaveFilterBank response_plot=filters.ResponsePlot(show=..., file=...)
stateful= y steady_ic= en OctaveFilterBank block_processing=filters.BlockProcessing(stateful=..., steady_ic=...)
polar=, polar_frequency= y directivity_index_db= en microphone_characteristics directivity=electroacoustics.MicrophoneDirectivity(polar=..., frequency=..., index=...)
noise_voltage=, equivalent_noise_level_db=, noise_weighting= y noise_spectrum= en microphone_characteristics noise=electroacoustics.MicrophoneNoise(voltage_v=..., equivalent_level=..., weighting=..., spectrum=...), cuya ponderación es "A" o "468", como dice la tabla de una grafía por concepto
max_spl_db=, max_spl_thd_percent= y distortion= en microphone_characteristics overload=electroacoustics.MicrophoneOverload(spl=..., thd_percent=..., distortion=...)
rated_impedance=, minimum_load_impedance=, powering= y supply_current_ma= en microphone_characteristics electrical=electroacoustics.MicrophoneElectrical(rated_impedance_ohm=..., min_load_impedance_ohm=..., powering=..., supply_current_ma=...)
directivity= (un RadiatingPistonResult), polar=, polar_frequency= y directivity_index_db= en loudspeaker_characteristics directivity=electroacoustics.LoudspeakerDirectivity(piston=..., polar=..., frequency=..., index=...)
rated_frequency_range=, rated_noise_power=, rated_sinusoidal_power= y resonance_frequency= en loudspeaker_characteristics ratings=electroacoustics.LoudspeakerRatings(frequency_range=..., noise_power=..., sinusoidal_power=..., resonance_frequency=...)
absorption_area=, reverberation_time=, volume=, mean_absorption_coefficient= y room_surface= en sound_power_pressure room=emission.RoomEnvironment(...), con los mismos cinco nombres
distance, source_height y receiver_height por posición, y projected_distance=, en predicted_receiver_level environment.PropagationGeometry(distance=..., source_height_m=..., receiver_height_m=..., projected_distance=...) como segundo argumento, tras el nivel de potencia acústica
ground_source=, ground_middle= y ground_receiver= en predicted_receiver_level ground=environment.GroundFactors(source=..., middle=..., receiver=...)
directivity_index= y d_omega= en predicted_receiver_level directivity=environment.DirectivityCorrection(index=..., d_omega=...)
ground_roll=, landing_roll= y bank= en aircraft.event_level y noise_contour segments=aircraft.FlightSegmentState(ground_roll=..., landing_roll=..., bank=...)
atmospheric_method= en rotorcraft_event_level y rotorcraft_noise_contour el atmospheric_method de su RotorcraftAtmosphere
receiver_height=, ground_elevation=, flow_resistivity=, terrain= y terrain_resolution= en esas mismas dos ground=aircraft.RotorcraftGround(receiver_height_m=..., ground_elevation=..., flow_resistivity=..., terrain=..., terrain_resolution=...)
airspeed=, path_angle=, heading= y bank_angle= en esas mismas dos track_state=aircraft.RotorcraftTrackState(airspeed=..., path_angle_deg=..., heading=..., bank_angle_deg=...)
scaling_factor= y triangles= en esas mismas dos interpolation=aircraft.FlightConditionInterpolation(scaling_factor=..., triangles=...)

OctaveFilterBank(48000, 3) se lee como antes, porque los cuatro argumentos que se escriben por posición conservaron su sitio; en octave_filter, toda opción que va detrás de limits se escribe por su nombre.

import numpy as np
from phonometry import filters
x = np.random.default_rng(0).standard_normal(48_000)
try:
filters.octave_filter(x, 48_000, calibration_factor=2.0)
except TypeError as error:
print(type(error).__name__)
# TypeError
result = filters.octave_filter(x, 48_000, calibration=filters.LevelCalibration(factor=2.0))
print(len(result.frequencies))
# 11

Veintidós funciones de la 3.3.0 tomaban como números sueltos el aire en el que calculan: una velocidad del sonido y una densidad, en los modelos viscotérmicos una viscosidad, un número de Prandtl, una relación de calores específicos y una presión estática, y en la corrección térmica de la ISO 9053-2 un calor específico y una conductividad térmica, cada uno con su propio valor por defecto. En la 4.0 estas veintidós toman un único fluid=, un fluids.Fluid que lleva todas las propiedades que lee su modelo, y sus palabras clave sueltas han desaparecido, así que una llamada que pasaba una lanza TypeError. Otras funciones que toman una velocidad del sonido o una densidad, entre ellas expansion_chamber, conservan sus propias palabras clave. Si se omite, fluid= es materials.ABSORBER_AIR, que guarda los valores por defecto de la 3.3.0: 343 m/s, 1,205 kg/m³, 1,84·10⁻⁵ Pa s, un número de Prandtl de 0,71, una relación de calores específicos de 1,4 y 101,325 kPa. Una llamada que nunca pasó el aire da el número que daba.

3.3.0 4.0
speed_of_sound= y air_density= en delany_bazley, miki, membrane_resonance_frequency, mass_law_transmission_loss, single_panel_transmission_loss, double_wall_transmission_loss, mass_spring_mass_resonance, ground_effect y barrier_insertion_loss fluid=
speed_of_sound=, air_density= y viscosity= en layered_absorber y diffuse_field_absorption; air_density= y viscosity= en perforated_plate_impedance y microperforated_plate_impedance fluid=
speed_of_sound=, air_density=, viscosity=, prandtl_number=, heat_capacity_ratio= y atmospheric_pressure= en johnson_champoux_allard, slit_helmholtz_absorber y critical_coupling_design, y los mismos salvo speed_of_sound= en helmholtz_resonator_impedance, slit_effective_properties y rectangular_duct_properties fluid=, cuyo static_pressure_pa es la presión, en pascales como antes
air_density= en atmospheric_parabolic_equation fluid=
speed_of_sound=, air_density=, specific_heat_ratio=, specific_heat_cp= y thermal_conductivity= en effective_kappa, y los mismos salvo specific_heat_ratio= en thermal_boundary_layer_thickness fluid=, con otro valor por defecto, más abajo

Pasa como un Fluid el aire al que te refieres. fluids.air() calcula uno a una temperatura, una humedad y una presión, y un Fluid construido a mano lleva los números que imprime un libro. Un modelo que lee una propiedad que el fluido no lleva lanza fluids.FluidPropertyUnavailableError, nombrándola.

import numpy as np
from phonometry import fluids, materials
f = np.array([250.0, 1000.0])
print(materials.delany_bazley(f, 20_000.0).characteristic_impedance.round(1))
# [971.5-775.5j 609.6-281.1j]
book_air = fluids.Fluid(
temperature_c=20.0,
static_pressure_pa=101_325.0,
composition={},
model="el aire del libro que se reproduce",
validity="",
properties={"speed_of_sound": 340.0, "density": 1.21},
)
# delany_bazley(f, 20000.0, speed_of_sound=340.0, air_density=1.21) en la 3.3.0
print(materials.delany_bazley(f, 20_000.0, fluid=book_air).characteristic_impedance.round(1))
# [965.3-769.6j 606.1-279.j ]

Dos de las veintidós toman otro aire por defecto. effective_kappa y thermal_boundary_layer_thickness, la corrección térmica de la ISO 9053-2, tomaban por defecto en la 3.3.0 los cinco valores que imprime el Anexo A.3 de la ISO 9053-2, dos de los cuales no son del aire que el anexo dice usar (registro de erratas). En la 4.0 toman ese aire, el del Anexo F de IEC 61094-2 en el estado del Anexo A.3: 23 °C, 101,325 kPa y un 50 % de humedad relativa. La corrección se mueve en su quinta cifra, effective_kappa(0.01, 0.001, 250.0) es 1,400297 donde era 1,400339, y los resultados impresos del Anexo A.3 siguen saliendo.

Un parámetro que nombra una magnitud lleva su unidad

Sección titulada «Un parámetro que nombra una magnitud lleva su unidad»

En todo lo demás, las condiciones ambientales conservaron su sitio y ganaron un sufijo. La regla es que un parámetro público que nombra una magnitud dimensional termina en la unidad que teclea quien llama, porque el número es donde se pierde la unidad y ninguna guardia puede cazarlo por magnitud: 101,325 y 101325 son las dos presiones legítimas en esta biblioteca.

3.3.0 4.0
temperature= temperature_c=
pressure= en air_attenuation, air_attenuation_m (ahora air_power_attenuation_per_m), atmospheric_attenuation, atmospheric_absorption, outdoor_propagation_attenuation, sae_band_attenuation (ahora band_attenuation_arp5534), impedance_adjustment y atmospheric_adjustment, y en los métodos event_level y noise_contour de AnpAircraft y AnpDatabase; static_pressure= en meteorological_corrections, sound_power_anechoic, sound_power_reverberation y sound_power_comparison; los campos AtmosphericAttenuation.pressure, AircraftBandAttenuation.pressure y ReportMetadata.pressure, todos en kPa static_pressure_kpa= y .static_pressure_kpa
static_pressure= en alternating_airflow_resistance, barometric_pressure= en sound_power_intensity_precision, atmospheric_pressure= en enclosed_gas_stiffness y floating_floor_resonance static_pressure_pa=
atmospheric_pressure= en air_density_iso (ahora air_density_iso10534) y air_density_astm (ahora air_density_astm_e2611) static_pressure_kpa= en air_density_iso10534 y air_density_astm_e2611
atmospheric_pressure= en johnson_champoux_allard y en las funciones de sonido lento el fluid= que reciben ahora, que lleva su propia presión estática
humidity=, relative_humidity= relative_humidity_percent=
diameter= y sus trece compuestos diameter_m=
angle=, angles=, bank_angle=, path_angle=, grazing_angle=, launch_angles= _deg= o _rad=, según lo que lea la función
runway_gradient= runway_gradient_ratio=
sound_speed_gradient= sound_speed_gradient_per_s=

La presión del medio tiene un solo nombre. static_pressure_kpa o static_pressure_pa es la presión absoluta del medio en el que se calcula la magnitud (el aire, un gas o el agua de mar), en la unidad en la que la escribe su apartado; la presión de una corriente medida en un conducto es manométrica y lo dice (static_gauge_pressure_pa), o es la static_pressure_pa de velocity_pressure_pa y total_pressure, cuyas fórmulas la leen así. atmospheric_pressure_pa se reserva para la atmósfera exterior allí donde el mismo método mide a su lado la presión de una corriente: pipe_transmission_loss, DownstreamPipe, normal_air_density y gas_density_kg_m3.

Un caso merece mención propia porque era una trampa y no una incomodidad. critical_angle era un campo en radianes en un resultado y un parámetro en grados en las dos funciones que estaban una pantalla más abajo, o sea la misma palabra para dos cosas separadas por un factor 57. Ahora es critical_angle_rad en el resultado y critical_angle_deg en los parámetros.

transmission_loss= pasó a propagation_loss= sólo en los resultados de sónar y de propagación numérica submarina. ReactiveSilencerResult y SoundReductionResult siguen llamando al suyo transmission_loss=, y con razón: es como lo llaman las normas que hay detrás.

Las funciones de la EN 29052-1 de materials siguen la misma regla, con la unidad de cada magnitud al final de su nombre:

3.3.0 4.0
apparent_dynamic_stiffness(resonant_frequency=, total_mass_per_area=) resonant_frequency_hz=, total_mass_per_area_kg_m2=
enclosed_gas_stiffness(thickness=) thickness_m=
installed_dynamic_stiffness(apparent_stiffness, airflow_resistivity, gas_stiffness=) apparent_stiffness_n_m3, airflow_resistivity_kpa_s_m2= sólo por nombre, gas_stiffness_n_m3=
natural_frequency(dynamic_stiffness=, mass_per_area=) dynamic_stiffness_n_m3=, mass_per_area_kg_m2=
floating_floor_resonance(resonant_frequency=, total_mass_per_area=, floor_mass_per_area=, airflow_resistivity=, thickness=) resonant_frequency_hz=, total_mass_per_area_kg_m2=, floor_mass_per_area_kg_m2=, airflow_resistivity_kpa_s_m2=, thickness_m=

La resistividad al flujo es la que se gana la palabra clave. La EN 29052-1 pone sus umbrales en kPa·s/m², y todas las demás resistividades al flujo de la biblioteca van en Pa·s/m², una unidad mil veces menor, así que una cifra en Pa·s/m² pasada por posición caía sin aviso en la rama equivocada del apartado 8.2; ahora se escribe por su nombre. Y por debajo de 100 kPa·s/m², installed_dynamic_stiffness ya no toma como cero un término de gas ausente: la 3.3.0 devolvía con installed_dynamic_stiffness(20e6, 50.0), la Fórmula 6 sin su segundo término, y la 4.0 lanza un error y pide .

Las funciones de la ISO 13472-1 de materials escriben el micrófono entero y dan las dos alturas en metros, y dos temperaturas dicen en qué escala están:

3.3.0 o 4.0.0rc1 4.0
mic_height= y source_height= en todas las funciones de la ISO 13472-1 de materials que los toman, y en plot_insitu_geometry microphone_height_m=, source_height_m=
InsituAbsorptionResult.mic_height y .source_height .microphone_height_m y .source_height_m
GasStream.inlet_temperature_k, en kelvin inlet_temperature_c, en grados Celsius: convierte el número, como enseña la sección de arriba
RoadEmissionCoefficients.temperature_k, la de CNOSSOS-EU en dB por grado, que se leía como una temperatura en kelvin temperature_coefficient_db_per_k: un coeficiente por grado es por kelvin, el mismo número que por grado Celsius

Las longitudes llevan su unidad allí donde una segunda unidad se disputa la palabra. Un espesor va en metros en una capa y en milímetros en la fila del catálogo de la que se lee, una separación son metros entre dos micrófonos o hercios entre dos líneas espectrales, una altura son metros sobre el suelo y decibelios en una meseta de coincidencia, y el paquete de aeronaves lee sus tablas nivel-potencia-distancia (NPD) en pies y calcula en metros:

3.3.0 o 4.0.0rc1 4.0
thickness= en PorousLayer, AirLayer, PerforatedPlateLayer, MicroperforatedPlateLayer, PoroelasticLayer, TransferMatrix, BarrierInsertionLoss y en toda función que lo recibía: las de Biot, de cuatro micrófonos, de placa perforada, de resistencia al flujo, de capas elásticas, de revestimientos de suelo, de paneles, de flancos, de transmisión estructural, de SEA y de movilidad puntual, y las funciones que dibujan la geometría; thickness1= y thickness2= en junction_transmission, junction_wave_parameters, right_angle_transmission_coefficient, point_connection_coupling_loss_factor, JunctionTransmissionResult y plot_junction_geometry; wall_thickness=, lining_thickness=, plate_thickness=, splitter_thickness=; specimen_thickness= en plot_dynamic_stiffness_rig y sample_thickness= en plot_impedance_tube_geometry thickness_m=, thickness1_m=, thickness2_m=, wall_thickness_m=, lining_thickness_m=, plate_thickness_m=, splitter_thickness_m=, specimen_thickness_m=, sample_thickness_m=
spacing= en sound_intensity e IntensityResult, en las funciones de la IEC 61043 e IntensityInstrumentComplianceResult, y en las funciones del tubo de impedancia e ImpedanceTubeResult spacing_m=
line_spacing= en las funciones de tonos de la ISO/PAS 20065 y ToneAudibilityResult; ZoomFFTResult.bin_spacing line_spacing_hz=; .bin_spacing_hz
height=, heights=, source_height=, receiver_height=, barrier_height=, max_height=, height_step=, slit_height=, plenum_height=, drop_height= y las demás alturas en metros, entre ellas height_fundamental_frequency(height=) el mismo nombre terminado en _m
plateau_height= en plateau_transmission_loss y SoundReductionResult plateau_height_db=
distance=, distances= y sus compuestos en aircraft: npd_level, npd_curve, event_level, noise_contour, noise_fraction, AnpNpdCurves, AnpDatabase, RotorcraftHemisphere, hover_ring_hemisphere, las funciones de propagación de helicópteros y sus resultados distance_m=, distances_m=, reference_distance_m=, horizontal_distance_m=, scaled_distance_m=, query_distances_m=, table_distances_m
ReportMetadata(mic_spacing=, thickness=) microphone_spacing_m=, thickness_m=
center=, width= y wavelength= en FDTD2D.add_plane_wave center_m=, half_width_m= (la semianchura en 1/e, como GaussianPulse.half_width_s lo es en el tiempo) y wavelength_m=, junto a las anchuras que el motor cuenta en celdas

Trece longitudes se escriben además por su nombre, porque llevan valor por defecto y el nombre es el único sitio donde se ve la unidad: npd_curve(query_distances_m=), static_airflow_resistance(thickness_m=), los campos distance_m, spacing_m y source_height_m de RotorcraftHemisphere, IntensityResult y RoadEmissionResult, los thickness1_m y thickness2_m que JunctionTransmissionResult guarda para su dibujo, y los source_height_m y microphone_height_m de la ISO 13472-1 en geometric_spreading_factor, geometric_spreading_factor_angle e InSituAbsorptionResult. La sección de conducto que lee duct_path es {"width_m": a, "height_m": b}, y TABLE_D1_QUANTITIES nombra thickness_m entre las magnitudes que describen una fila de la Tabla D.1. Las filas de los catálogos conservan thickness_mm, la unidad en la que el catálogo guarda todas sus filas, sea cual sea la que imprime su fuente, y vertical_directivity(height=1) conserva su nombre, porque 1 o 2 elige una línea de fuente y no es una longitud.

Una tasa, una velocidad y una fase también llevan su unidad. Un coeficiente de absorción en dB/km junto al coeficiente de absorción adimensional de una pared, la velocidad de un vehículo en km/h junto a una velocidad del viento en m/s y una de vuelo en nudos, y una fase en radianes en una función de transferencia junto a otra en grados en un registro de calibración eran, cada una, la misma palabra para dos cosas:

3.3.0 o 4.0.0rc1 4.0
absorption_coefficient en PropagationLossResult, GaussianBeamResult y DetectionRangeResult, en dB/km absorption_db_per_km
air_absorption_coefficient= en sound_power_anechoic y meteorological_corrections, en dB/m air_absorption_db_per_m=, la grafía que usa CalibrationConditions
AtmosphericAttenuation.attenuation_coefficient, en dB/m .attenuation_db_per_m
air_attenuation= en sabine_reverberation_time, eyring_reverberation_time, millington_sette_reverberation_time, fitzroy_reverberation_time, arau_puchades_reverberation_time, reverberation_time_models e image_source_rir, y SoundAbsorptionMeasurement.air_attenuation air_attenuation_per_m
attenuation= en tube_wavenumber y two_microphone_impedance, en Np/m attenuation_np_per_m=
attenuation_source= y attenuation_receiving= en plenum_flanking_reduction_index attenuation_source_per_m= y attenuation_receiving_per_m=
speed= en road_rolling_noise, road_propulsion_noise, road_vehicle_sound_power, aerodynamic_sound_power y roughness_to_frequency; RoadTraffic.speed, RailwayVehicle.speed y RoadSurfaceCoefficients.speed_range; railway_source_power(minimum_speed=), todos en km/h speed_kmh, speed_range_kmh y min_speed_kmh=; RailwayVehicle toma speed_kmh= por su nombre
reference_speed= en event_level, noise_contour y duration_correction, y segment_speed= en duration_correction reference_speed_m_s= y segment_speed_m_s=
FlightPathKinematics.airspeed y .ground_speed, en m/s .airspeed_m_s y .ground_speed_m_s
ground_speed= en linear_sound_speed_profile, log_linear_sound_speed_profile, ray_curvature_radius y shadow_zone_distance, la velocidad del sonido junto al suelo ground_speed_of_sound=
RayTraceResult.profile_speeds .profile_speeds_of_sound
blade_passing_frequency(rotational_speed=) rotational_speed_rpm=
.phase en FrequencyResponseResult, CrossSpectralDensityResult, PhaseDecompositionResult, EnvelopeResult y MobilityResult; .minimum_phase y .excess_phase en PhaseDecompositionResult; CrossSpectralDensityResult.phase_std, todos en radianes .phase_rad, .min_phase_rad, .excess_phase_rad y .phase_standard_deviation_rad
residual_index_from_phase_mismatch(phase_mismatch=) e IntensityInstrumentComplianceResult.phase_mismatch(), en grados phase_mismatch_deg= y .phase_mismatch_deg()

Un nombre tiene además una sola grafía dentro de un paquete. Donde una palabra era pública a la vez sin unidad y con ella en un mismo paquete, ahora conserva la unidad si otra unidad compite por ella, como en la primera tabla de abajo, y la pierde si la palabra solo tuvo nunca una, como en la tabla de «Una grafía por concepto»:

3.3.0 o 4.0.0rc1 4.0
RotorcraftHemisphere.azimuth y .polar, RotorcraftEventResult.azimuth y .polar, en grados .azimuth_deg y .polar_deg, como los recibe hemisphere_source_level
sae_band_attenuation(path_length=) (ahora band_attenuation_arp5534) y AircraftBandAttenuation.path_length path_length_m
gap= en double_wall_transmission_loss, mass_spring_mass_resonance y plot_double_wall_geometry, y SoundReductionResult.gap, en metros gap_m, junto al gap_mm de una serie de juntas
HeavyImpactSourceSpec.tolerance y HeavyImpactSourceCheck.tolerance, en dB .tolerance_db
LoudspeakerCharacteristics.input_voltage y loudspeaker_characteristics(input_voltage=), MicrophoneNoise.voltage input_voltage_v y voltage_v, como los escriben los registros de bucle de inducción
LoudspeakerCharacteristics.rated_frequency_range, MicrophoneCharacteristics.reference_frequency y microphone_characteristics(reference_frequency=) rated_frequency_range_hz y reference_frequency_hz, como los escriben los registros de auriculares
SweptSineDistortionResult.thd, una razón .thd_ratio, junto al thd_percent de los registros de altavoz y de micrófono
roughness_to_frequency(wavelengths=), en milímetros wavelengths_mm=, junto al wavelengths_m de un espectro de la EN 15610
sea_water_sound_speed(salinity=, depth=, latitude=) salinity_psu=, depth_m= y latitude_deg=, como los reciben sea_water y sea_water_density
depth= en metadiffuser_reflection, metadiffuser_polar_response, metadiffuser_diffusion_spectrum y plot_metadiffuser_panel_geometry, y MetadiffuserResult.depth, en metros depth_m, junto al depth_mm de una muestra de techo
DynamicStiffnessResult.resonant_frequency, .apparent_stiffness, .dynamic_stiffness, .gas_stiffness y .floor_mass_per_area .resonant_frequency_hz, .apparent_stiffness_n_m3, .dynamic_stiffness_n_m3, .gas_stiffness_n_m3 y .floor_mass_per_area_kg_m2, como los reciben las funciones de la EN 29052-1 junto a los MN/m³ que imprime la norma
johnson_champoux_allard(viscous_length=, thermal_length=), en metros viscous_length_m= y thermal_length_m=, junto a los micrómetros de una fila de catálogo
CorrelationResult.duration y correlation_random_error(duration=), en segundos duration_s, junto al duration_hours de lex_8h
LevelCrossingResult.duration y PeakStatisticsResult.duration, en segundos .duration_s, junto al duration_ms de una ráfaga tonal de la IEC 61672-1
RigidMassCalibrationResult.tolerance y .deviation, y tolerance= en seat_transmission y mean_of_test_runs, cifras relativas relative_tolerance y relative_deviation
LabAirborneInsulationResult.absorption y LabImpactInsulationResult.absorption, el área A en m² .absorption_area
HelmholtzResonator(neck_length=, neck_side=, cavity_length=, cavity_side=); lattice_step= en slit_helmholtz_absorber, helmholtz_resonator_impedance, critical_coupling_design, plot_slit_absorber_geometry y SlitResonatorAbsorberResult; critical_coupling_design(cavity_length_bounds=) y rectangular_duct_properties(side=) los mismos nombres terminados en _m
width= en plane_wave_limit, rectangular_duct_cut_on, elbow_insertion_loss, lined_rectangular_duct_attenuation, unlined_rectangular_duct_attenuation y hydraulic_diameter width_m=, junto a su height_m=
width= en outdoor_attenuation, typical_element_mobility, slit_transmission_coefficient, slit_resonance_frequencies y plot_aperture_geometry, y ApertureTransmissionResult.width, en metros width_m, junto al height_m de una fachada y al joint_width_mm de una junta
AircraftBandAttenuation.coefficient, en dB/m .coefficient_db_per_m, junto al coefficient_db_per_100m de un resultado de la ARP 866A
LoudspeakerCharacteristics.rated_impedance, .minimum_impedance y .impedance_modulus, y loudspeaker_characteristics(rated_impedance=); rated_impedance y minimum_load_impedance en MicrophoneCharacteristics y MicrophoneElectrical, y microphone_characteristics(rated_impedance=, minimum_load_impedance=) de la 3.3.0, todos en ohmios los mismos nombres terminados en _ohm, como los escriben los registros de auriculares y de bucle de inducción junto a las impedancias mecánicas de un pistón, con el mínimo escrito min_ (rated_impedance_ohm, min_impedance_ohm, impedance_modulus_ohm, min_load_impedance_ohm); el par del micrófono se da como microphone_characteristics(..., electrical=MicrophoneElectrical(rated_impedance_ohm=..., min_load_impedance_ohm=...))
flow_resistivity= en ground_effect, atmospheric_parabolic_equation, delany_bazley, miki, johnson_champoux_allard y decoupling_frequency, PorousMediumResult.flow_resistivity y barrier_insertion_loss(ground_flow_resistivity=), en Pa s/m² flow_resistivity_pa_s_m2 y ground_flow_resistivity_pa_s_m2, junto a los kPa s/m² de las clases de suelo de la IEC TS 61400-11-2 y de la EN 29052-1

Una constante publicada sigue la misma regla, y la necesita más, porque un número suelto no tiene más que su nombre para decir en qué está: 10.0 son hercios, decibelios o una cuenta. La constante que guarda un solo número termina en su unidad, o en _DB cuando está en decibelios, salvo que sea una cuenta, un factor o una razón; la tabla cuyo nombre dice lo que guarda (bandas, velocidades, alturas) termina en la unidad de eso. Las constantes que exportaba la raíz de la 3.3.0 están en la tabla de nombres que ya no están, al final de esta página; estas son las demás.

3.3.0 o 4.0.0rc1 4.0
noise_control.ISO7235_GAS_CONSTANT, 287 J/(kg K) ISO7235_AIR_GAS_CONSTANT_J_KG_K
noise_control.UNIVERSAL_GAS_CONSTANT, 8314 J/(kmol K) IEC60534_MOLAR_GAS_CONSTANT_J_KMOL_K
noise_control.AIR_SOUND_SPEED_M_S, PIPE_SOUND_SPEED_M_S AIR_SPEED_OF_SOUND_M_S, PIPE_SPEED_OF_SOUND_M_S
environment.ROAD_REFERENCE_SPEED, RAILWAY_MINIMUM_SPEED, TRAM_MINIMUM_SPEED, AERODYNAMIC_THRESHOLD_SPEED, AERODYNAMIC_REFERENCE_SPEED, todas en km/h ROAD_REFERENCE_SPEED_KMH, RAILWAY_MIN_SPEED_KMH, TRAM_MIN_SPEED_KMH, AERODYNAMIC_THRESHOLD_SPEED_KMH, AERODYNAMIC_REFERENCE_SPEED_KMH
environment.ROAD_REFERENCE_TEMPERATURE ROAD_REFERENCE_TEMPERATURE_C
environment.ROAD_SOURCE_HEIGHT, RAILWAY_SOURCE_HEIGHTS ROAD_SOURCE_HEIGHT_M, RAILWAY_SOURCE_HEIGHTS_M
environment.ROAD_OCTAVE_BANDS, RAILWAY_OCTAVE_BANDS, RAILWAY_THIRD_OCTAVE_BANDS los mismos nombres terminados en _HZ
building.LOW_FREQUENCY_BANDS LOW_FREQUENCY_PROCEDURE_BANDS_HZ, junto a la environment.LOW_FREQUENCY_BANDS_HZ de otra norma
building.HEAVY_IMPACT_OCTAVE_BANDS, TABLE_F1_OCTAVE_BANDS, DB_HR_FREQUENCIES los mismos nombres terminados en _HZ
building.TAPPING_DROP_HEIGHT, TAPPING_HAMMER_RADIUS, TAPPING_HAMMER_MASS, TAPPING_IMPACT_RATE TAPPING_DROP_HEIGHT_M, TAPPING_HAMMER_RADIUS_M, TAPPING_HAMMER_MASS_KG, TAPPING_IMPACT_RATE_HZ
building.LOW_FREQUENCY_VOLUME_LIMIT LOW_FREQUENCY_VOLUME_LIMIT_M3
hearing.AUDIOMETRIC_FREQUENCIES, PROTECTOR_OCTAVE_BANDS AUDIOMETRIC_FREQUENCIES_HZ, PROTECTOR_OCTAVE_BANDS_HZ
building.MINIMUM_MULTI_JUNCTION_KIJ, −5 dB MIN_MULTI_JUNCTION_KIJ
broadcast.DBQPS_REFERENCE, 0,775 V DBQPS_REFERENCE_V
electroacoustics.CARDIOID_RELATIVE_DIRECTIVITY, DEFAULT_STABILITY_MARGIN, las dos en dB los mismos nombres terminados en _DB
environment.REFERENCE_JOINT_DENSITY, juntas por metro REFERENCE_JOINT_DENSITY_PER_M
noise_control.ISO7235_ABSOLUTE_ZERO_OFFSET, 273 K ISO7235_ABSOLUTE_ZERO_OFFSET_K
psychoacoustics.ERB_C1, en Hz, y ERB_C2, por hercio ERB_C1_HZ, ERB_C2_PER_HZ
room.COMMUNICATION_SNR, PRIVACY_SNR, las dos en dB los mismos nombres terminados en _DB
vibration.UNCONSTRAINED_BELOW, el −100 % de la ISO 8041-1 UNCONSTRAINED_BELOW_PERCENT, junto a CENTRAL_TOLERANCE_PERCENT y las demás

Las constantes de los gases enseñan por qué una constante necesita su unidad tanto como un parámetro. Dos constantes de un mismo paquete compartían las palabras «constante de los gases» para 287 J/(kg K) y 8314 J/(kmol K), y fluids publica 8,314 J/(mol K) como tercera: tres cifras separadas por factores de 29 y de 1000 bajo un mismo nombre. Ahora cada una lleva su unidad entera.

Una señal temporal que es una sola magnitud física se nombra por ella, con su unidad, como ya hacía velocity_mm_s en las funciones de la DIN 4150 y la DIN 45669; una señal en cualquier unidad es x. Solo cambia una llamada que escribía la señal por su nombre:

3.3.0 o 4.0.0rc1 4.0
pressure= en underwater.sound_pressure_level, peak_sound_pressure_level, sound_exposure_level, pile_strike_metrics, single_strike_sel y strike_sel_spectrum, y PileStrikeResult.pressure pressure_pa
acceleration= en vibration.acceleration_dose, spinal_response y multiple_shock_assessment acceleration_m_s2=
force= en building.impact_force_exposure_level y vibration.injected_power force_n=

Las condiciones y las banderas se escriben por su nombre

Sección titulada «Las condiciones y las banderas se escriben por su nombre»

Una condición del ambiente o del medio o un factor de calibración que lleva valor por defecto, y toda bandera booleana pública, son keyword-only. Las condiciones son la temperatura, la humedad y la presión estática, la velocidad del sonido y la densidad del medio, y los tres factores de suelo de ISO 9613-2. La regla existe porque el sitio donde se pierde el significado es la llamada: air_attenuation(freqs, 20.0, 50.0, 101.325) son una temperatura, una humedad y una presión en un orden que no recuerda nadie, y bank.filter(x, True) no dice cuál de cinco banderas se ha activado. La elección de un método o de un conjunto de bandas y un recuento (mode, method, fraction, n, seed) son opciones, no condiciones, y la regla las deja donde estaban.

El fallo es ruidoso, que es de lo que se trata:

import numpy as np
from phonometry.signals import leq
x = np.random.default_rng(1).standard_normal(4800) * 0.01
try:
leq(x, 48000)
except TypeError as error:
print(error) # leq() takes 1 positional argument but 2 were given

Esa llamada merece una segunda mirada. leq nunca tuvo fs, porque una media energética no lo necesita, así que en la 3.3.0 el 48000 se ligaba en silencio a calibration_factor y la respuesta salía 93,6 dB alta sin una queja. Ahora es un TypeError, que es lo que siempre debió ser.

print(round(float(leq(x, dbfs=True)), 3))

Estas tomaban hasta ahora una condición o un factor de calibración por posición:

3.3.0 o 4.0.0rc1 4.0
signals.sound_exposure(x, fs, 8.0, cal) y lex_8h(x, fs, 8.0, cal) sound_exposure(x, fs, duration_hours=8.0, calibration_factor=cal)
psychoacoustics.sharpness_din(x, fs, "free", "din", cal) sharpness_din(x, fs, "free", "din", calibration_factor=cal)
environment.ground_attenuation(d, hs, hr, bands, gs, gm, gr) ground_attenuation(d, hs, hr, frequencies=bands, ground_source=gs, ground_middle=gm, ground_receiver=gr), y projected_distance= por su nombre
la velocidad del sonido por posición en IntensityInstrumentComplianceResult.phase_mismatch_deg, emission.phase_mismatch_from_residual_index, residual_index_from_phase_mismatch, environment.fresnel_number, spherical_reflection_coefficient, room.reflection_density, materials.reflected_path_delay, spot_tube_upper_frequency y spot_microphone_spacing_bounds speed_of_sound=
noise_control.LiquidPipe(d, t, rho, c, rho_air, c_air) LiquidPipe(internal_diameter_m=d, wall_thickness_m=t, density=rho, speed_of_sound=c, air_density=rho_air, air_sound_speed=c_air)
underwater.FluidSeabed(rho, c, rho_water) FluidSeabed(density=rho, speed_of_sound=c, water_density=rho_water)
io.Signal(data, fs, cal) io.Signal(data, fs, calibration_factor=cal), y channel_labels, provenance y source por su nombre
simulation.FDTD2D(c, dx, ...) (3.3.0) y simulation.ElasticFDTD2D(c_p, c_s, dx, rho=..., ...) (4.0.0rc1) FDTD2D(c=c, dx=dx, ...) y ElasticFDTD2D(c_p=c_p, c_s=c_s, dx=dx, rho=..., ...): todos los argumentos por su nombre, como toman los suyos FDTDRun y ElasticRun. FDTD2D(0.01, 343.0, shape=...), con la velocidad y el paso de malla intercambiados, construía un motor de celdas de 343 m y un paso de tiempo de unas cuatro horas

Un parámetro cuyo nombre lleva su unidad y que tiene valor por defecto se escribe también por su nombre. noise_signal(fs, 2.0) se lee como dos segundos solo si uno recuerda el orden, y el _s que lo dice está en el parámetro, no en la llamada:

3.3.0 o 4.0.0rc1 4.0
signals.noise_signal(fs, 2.0), speech.stipa_signal(fs, 18.0) noise_signal(fs, duration_s=2.0), stipa_signal(fs, duration_s=18.0)
underwater.ship_source_spectrum(12.0, 100.0) ship_source_spectrum(12.0, length_m=100.0)
la duración de cada muestra por posición en hearing.job_based_exposure sample_duration_hours=

Un eje de frecuencias se escribe también por su nombre, allí donde va junto a los valores que etiqueta. Dos arrays de la misma longitud se ligan en cualquier orden sin una queja, así que una llamada que los intercambia responde sobre el eje equivocado en vez de fallar; la propia referencia de la API traía weighted_rating_extended(freqs, r) y weighted_impact_rating_extended(freqs, ln) con las frecuencias donde van los niveles. Los valores siguen siendo posicionales, en el orden que tenían, y el eje pasa detrás del *:

import numpy as np
from phonometry import room, signals
frequencies = np.array([63.0, 125.0, 250.0, 500.0, 1000.0, 2000.0, 4000.0, 8000.0])
levels = np.array([62.0, 56.0, 50.0, 45.0, 41.0, 38.0, 36.0, 35.0])
print(room.noise_criterion(levels, frequencies=frequencies).rating)
smoothed = signals.fractional_octave_smoothing(levels, frequencies=frequencies, domain="db")
print(smoothed.shape)
try:
room.noise_criterion(levels, frequencies)
except TypeError as error:
print(error) # noise_criterion() takes 1 positional argument but 2 were given

El eje es frequencies, frequencies_hz en las dos funciones subacuáticas cuyas fórmulas se imprimen en kHz, y frequency donde una función evalúa una frecuencia o muchas. Un array cuyo nombre acaba en uno de ellos sigue la misma regla: las tone_frequencies junto a los niveles de tono de ISO/PAS 20065, o las critical_frequencies junto a los índices de reducción vibratoria de ISO 12354-1. Estas funciones lo tomaban hasta ahora por posición:

  • aircraft: hover_ring_hemisphere, terrain_screening_adjustment.
  • building: a_weighted_max_impact_level, apply_low_frequency_procedure, ceiling_attenuation_class, equivalent_absorption_length, impact_improvement, improvement_octave_bands, perimeter_absorption_coefficient, plate_loss_factor, reception_plate_power, reciprocity_impact_level, resonant_sound_reduction_index, structural_reverberation_time, structure_borne_power_level, tapping_machine_characteristic_power_level, tapping_machine_coupling_term, total_loss_factor, weighted_impact_rating_extended, weighted_rating_extended.
  • electroacoustics: loudspeaker_characteristics, microphone_characteristics.
  • emission: field_indicators, octave_band_levels, phase_mismatch_from_residual_index, precision_background_correction, residual_index_from_phase_mismatch, sound_energy_in_situ, sound_energy_reverberation, sound_power_in_duct, sound_power_in_situ, sound_power_reverberation, velocity_level_from_acceleration, verify_intensity_class.
  • environment: assess_tonal_survey, spherical_reflection_coefficient, tonal_correction, wind_turbine_tonality.
  • hearing: hearing_level_to_coupler_spl.
  • materials: diffusion_spectrum, equivalent_area_uncertainty, measure_sound_absorption, one_third_octave_absorption, practical_coefficient_uncertainty, scattering_coefficient_spectrum, sound_absorption_coefficient_uncertainty.
  • noise_control: duct_path, room_to_room_transmission, splitter_silencer_insertion_loss.
  • psychoacoustics: analyze_spectrum, assess_tones, combined_tone_level, equal_loudness_contours, mean_narrowband_level, tone_level.
  • room: noise_criterion, octave_pair_averages, room_criterion, room_modal_density, room_mode_count, single_number_average.
  • signals: fractional_octave_smoothing, cuyo fraction también se escribe ahora por su nombre.
  • underwater: monopole_source_level, weighted_exposure.
  • vibration: characteristic_phase_deviation, convert_frf, coupling_loss_factor, indirect_transfer_stiffness_result, power_injection_clf, power_injection_matrix, transfer_stiffness_indirect, verify_phase_response, verify_rigid_mass_calibration, verify_weighting, weighted_acceleration.

Un valor posicional que venía detrás del eje sigue siendo posicional y sube un puesto: convert_frf(value, f, "mobility", "impedance") es convert_frf(value, "mobility", "impedance", frequency=f).

Un eje de longitudes de onda se escribe por su nombre del mismo modo. environment.roughness_to_frequency(levels, wavelengths, speed) es roughness_to_frequency(levels, wavelengths_mm=wavelengths, speed_kmh=speed): los niveles de la tabla de rugosidad siguen siendo posicionales, y sus longitudes de onda se escriben por su nombre con la velocidad que va detrás, de modo que los km/h de la velocidad quedan también en la línea. materials.standing_wave_reflection(swr, x_min1, lam) y standing_wave_normalized_impedance(swr, x_min1, lam) toman por su nombre la longitud de onda de cada tono, wavelength=lam: es una longitud de la misma forma que la distancia al primer mínimo que va a su lado, y las dos se ligan en cualquier orden.

Una función de señal toma por posición las muestras y su frecuencia de muestreo, y por su nombre la magnitud que dice lo que hace con ellas. Estas tomaban esa magnitud por posición en la 3.3.0, incluso cuando es una elección, como el name de la ponderación de apply_weighting, o un recuento, como un order. La frecuencia de muestreo puede omitirse ahora cuando las muestras son un Signal, que lleva la suya:

3.3.0 4.0
linkwitz_riley(x, fs, 1000.0, 4) filters.linkwitz_riley(x, fs, frequency=1000.0, order=4), con el frequency que era freq
parametric_eq(x, fs, sections) filters.parametric_eq(x, fs, sections=sections)
zoom_fft(x, fs, 900.0, 1100.0) signals.zoom_fft(x, fs, f_min=900.0, f_max=1100.0)
lifter(x, fs, 0.002) signals.lifter(x, fs, cutoff=0.002)
time_synchronous_average(x, fs, 0.05) signals.time_synchronous_average(x, fs, period_s=0.05), el periodo en segundos, como dice ahora su nombre
resample_signal(x, fs, 32000) signals.resample_signal(x, fs, fs_new=32000)
harmonic_distortion(x, fs, 1000.0, 2) electroacoustics.harmonic_distortion(x, fs, fundamental=1000.0, order=2)
difference_frequency_distortion(x, fs, 1000.0, 1200.0) electroacoustics.difference_frequency_distortion(x, fs, f1=1000.0, f2=1200.0)
modulation_distortion(x, fs, 60.0, 7000.0) electroacoustics.modulation_distortion(x, fs, f_low=60.0, f_high=7000.0)
swept_sine_distortion(recorded, fs, 20.0, 20000.0, 2.0) electroacoustics.swept_sine_distortion(recorded, fs, f1=20.0, f2=20000.0, duration_s=2.0)
apply_weighting(x, fs, "Wk") vibration.apply_weighting(x, fs, name="Wk")
sound_intensity(p1, p2, fs, 0.012) emission.sound_intensity(p1, p2, fs, spacing_m=0.012)
import numpy as np
from phonometry import io, signals
fs = 8000
x = io.Signal(np.sin(2 * np.pi * 1000.0 * np.arange(fs) / fs), fs)
try:
signals.zoom_fft(x, fs, 900.0, 1100.0)
except TypeError as error:
print(error) # zoom_fft() takes from 1 to 2 positional arguments but 4 were given
zoom = signals.zoom_fft(x, f_min=900.0, f_max=1100.0)
print(zoom.frequencies[np.argmax(zoom.amplitude)]) # 1000.0

Un registro que construyes y entregas a una función se escribe por nombre del mismo modo: aircraft.RotorcraftHemisphere(freqs, az, po, levels) es RotorcraftHemisphere(frequencies=freqs, azimuth_deg=az, polar_deg=po, levels=levels), y una llamada posicional lanza TypeError. Un resultado que construye la biblioteca y que otra función recibe entero conserva sus campos donde estaban, porque nadie lo escribe campo a campo.

Todo registro que construyes y entregas a una función toma sus campos por nombre, no solo los que tienen un eje. Estos los tomaban por posición en la 3.3.0 o en la 4.0.0rc1:

  • aircraft: Aerodrome, AerodynamicCoefficients, ApproachStep, DepartureStep, FlightConditionInterpolation, JetEngineCoefficients, PerformanceAircraft, PropellerEngineCoefficients, RotorcraftGround.
  • broadcast: QuasiPeakBallistics.
  • building: ApertureTransmissionResult, BandPath, FacadeElement, FlankingPath, HomogeneousElement, LowFrequencyProcedure, SoundReductionResult.
  • electroacoustics: LoudspeakerDirectivity, LoudspeakerRatings, MicrophoneDirectivity, MicrophoneElectrical, MicrophoneNoise, MicrophoneOverload.
  • emission: GradeConditions, PrecisionFieldIndicators, RoomEnvironment.
  • environment: Barrier, DirectivityCorrection, EffectiveSoundSpeedProfile, GroundFactors, NoisePhase, PropagationGeometry, RailwayTrack, RailwayVehicle, RegulationLimits, RoadDeviceRating, RoadEmissionCoefficients, RoadSurfaceCoefficients, RoadTraffic, RollingStock, SourceEmission.
  • filters: EQSection, FilterDesign, LevelCalibration.
  • fluids: Fluid.
  • hearing: ExposureResult, HMLRatingResult, SNRRatingResult, Task.
  • io: BroadcastMetadata, SignalOrigin.
  • materials: AbsorptionRatingResult, AirLayer, BiotWavesResult, HelmholtzResonator, MembraneLayer, MetadiffuserWell, MicroperforatedPlateLayer, PerforatedPlateLayer, PoroelasticLayer, PorousLayer, PorousMediumResult.
  • metrology: Quantity.
  • noise_control: DesignCriterion, DownstreamPipe, DuctElement, Expander, GasStream, LiquidPipe, LiquidStream, LiquidTrim, RegimeBoundaries, RoomToRoomResult, SourceRoom, ValveTrim.
  • simulation: ContourPhasors, CWSource, ElasticBoundaries, ElasticRecording, ExplosionSource, ForceSource, GaussianPulse, Material, PlaneWaveSource, SignalSource.
  • underwater: BeamFan, FluidSeabed, RayTraceResult, VolumeAbsorption, WestonSeabed.
  • vibration: FaultFrequencyResult, FaultLine, WeightingVerification, ZoneBoundaries.

noise_control.DuctElement("Elbow", [0, 1, 2], [41, 39, 36]) es DuctElement(label="Elbow", attenuation=[0, 1, 2], self_noise=[41, 39, 36]). io.Signal(x, fs) es el único registro que conserva por posición sus dos primeros campos: las muestras y su frecuencia de muestreo son el par que toda función de la biblioteca recibe así.

Los nombres públicos se habían ido repartiendo entre varias grafías de la misma magnitud, y la 4.0 se queda con la que ya usaba la mayoría. La regla de las magnitudes que se cuentan en plural es la que seguía casi toda la API: un campo o un parámetro que guarda un array es frequencies, times, distances o levels, y uno que guarda un solo valor va en singular. Un argumento vectorizado que admite un número o un array conserva su nombre. Un eje no lleva la unidad en el nombre, porque su unidad nunca cambia: frequencies va en hercios, levels en decibelios y la frecuencia de muestreo es fs en todas las funciones.

3.3.0 o 4.0.0rc1 4.0
sound_speed (válvulas de control, medición de silenciadores, regímenes de Weston, ruido ambiente, FluidSeabed, ShipSourceLevelResult) speed_of_sound
c= y rho= en sound_intensity, c= en las dos conversiones de desajuste de fase, phase_mismatch() (ahora phase_mismatch_deg()), absorption_coefficient_uncertainty y monopole_source_level speed_of_sound=, density=
speed_of_sound_m_s= en thickness_critical_frequency_product speed_of_sound=
sample_rate en el SignalSource de FDTD, STOIResult e impact_force_exposure_level fs
sponge_width=, sponge_sides=, sponge_reflection= y .sponge_width/.sponge_sides en FDTD2D y ElasticFDTD2D absorbing_layer_cells=, absorbing_sides=, absorbing_layer_reflection= y .absorbing_layer_cells/.absorbing_sides, las palabras que usan los registros de una ejecución para la misma capa, como FDTDBoundaries.absorbing_layer_cells y ElasticBoundaries.absorbing_layer_cells; el valor por defecto sigue siendo 0, sin capa
FDTD2D.plot_geometry(probes=) en metros (4.0.0rc1) celdas (ix, iy), como FDTDRecording.probes; cada una se dibuja en el centro de celda que anota FDTDResult.probe_positions, y una celda fuera de la malla o dentro de un obstáculo se rechaza como la rechaza una ejecución
freq= en linkwitz_riley y adaptation_term_kc frequency= y frequencies=
band["freq"] en las filas bands de FilterComplianceResult, WeightingComplianceResult e IntensityInstrumentComplianceResult, y between_nominals["worst_freq"] en WeightingComplianceResult band["frequency"] y between_nominals["worst_frequency"]
.frequency en los resultados que llevan un eje de frecuencias: IntensityResult, FieldIndicators, IntensityInstrumentComplianceResult, RoomAcousticsResult, los cinco resultados de auditorio, ImpedanceTubeResult, PorousMediumResult, LayeredAbsorberResult, DiffuseFieldAbsorptionResult, BiotWavesResult, SlitResonatorAbsorberResult, MetadiffuserResult, TransferMatrix, los dos resultados de ruido de válvulas, AircraftBandAttenuation, AmbientNoiseResult, ShipTrafficSpectrum .frequencies
.band_centers en las clasificaciones de ISO 717 e ISO 11654 (WeightedRatingResult, ImpactRatingResult, ExtendedWeightedRatingResult, ExtendedImpactRatingResult, AbsorptionRatingResult), .centre_frequencies en EcmaLoudness, EcmaTonality, EcmaRoughness, EcmaFluctuationStrength y MooreGlasbergLoudness, .band_frequencies en FilterComplianceResult y STOIResult, .bands_hz en RoadDeviceRating .frequencies, el eje de bandas de todos los resultados
frequency= con un array: las funciones de transmisión por flancos, internal_spectrum, pipe_transmission_loss, expander_noise, transfer_matrix_one_load, transfer_matrix_two_load, TransferMatrix.plot frequencies=
level= y frequency= con un eje de bandas: apply_low_frequency_procedure, heavy_impact_octave_levels, a_weighted_maximum_impact_level, standardized_maximum_impact_level, ceiling_attenuation_class, plenum_flanking_reduction_index, single_number_average, octave_pair_averages, one_third_octave_absorption, power_injection_matrix, power_injection_clf, valve_hydrodynamic_noise, indirect_transfer_stiffness_result, y frequency_hz= en ship_source_spectrum levels= y frequencies=
frequency_hz= con un array en weighted_exposure y ocean_ambient_noise frequencies_hz=; la unidad se queda porque las fórmulas que evalúan están impresas en kHz
.time en ZwickerLoudness, EcmaLoudness, MooreGlasbergTimeVaryingLoudness, los resultados de tonalidad, aspereza y fuerza de fluctuación de ECMA-418-2, DecayCurve, QuasiPeakResult .times
.level en DecayCurve, NpdLevelResult, NoiseContourResult, RotorcraftNoiseContourResult, LowFrequencyResult, DuctPathStage, LateLateralResult, TransferStiffnessResult .levels
.distance en NpdLevelResult y RotorcraftEventResult .distances_m
frequencies_hz en las comprobaciones del instrumento de vibración humana (WeightingVerification, PhaseVerification, characteristic_phase_deviation, verify_phase_response), levels_db= en operating_standard_deviation y subinterval_level frequencies, levels
sound_speeds en EffectiveSoundSpeedProfile y sound_speeds= en normal_modes, ray_trace, gaussian_beams y parabolic_equation speeds_of_sound
SoundSpeedProfile.sound_speed y .depth .speeds_of_sound y .depths
omc_uncertainty= en sound_power_pressure y sound_energy_pressure, sigma_omc= en sound_power_anechoic, precision_uncertainty, sound_power_in_situ y sound_energy_in_situ, .sigma_omc en InSituSoundPowerResult sigma_omc_db
level=, measured_level=, operational_level= en sti_from_impulse_response, stipa, sti_adjusted_for_levels y STIResult.adjusted_for_levels levels=, measured_levels=, operational_levels=
.passed en AircraftSystemComplianceResult, QuasiPeakDynamicsResult, HeavyImpactSourceCheck, RigidMassCalibrationResult .passes, como en todos los demás verificadores
microphone_characteristics(noise_weighting="CCIR") (3.3.0, donde la ponderación era una etiqueta libre) y MicrophoneNoise(weighting="CCIR") (4.0.0rc1) noise=MicrophoneNoise(weighting="468"), la grafía que usan weighting_filter y weighted_thd para la curva UIT-R BS.468-4. La ponderación es "A" o "468", y microphone_characteristics rechaza cualquier otra con ValueError
atmospheric_pressure_kpa= en las funciones de la ISO 9613-1, atmospheric_absorption, outdoor_propagation_attenuation, AtmosphericAttenuation, AtmosphericConditions, sae_band_attenuation (ahora band_attenuation_arp5534), AircraftBandAttenuation, AerodromeAtmosphere, RotorcraftAtmosphere, impedance_adjustment, atmospheric_adjustment, los métodos de AnpAircraft y AnpDatabase, air_density_iso10534 y air_density_astm (ahora air_density_astm_e2611); atmospheric_pressure_pa= en enclosed_gas_stiffness y floating_floor_resonance; barometric_pressure_pa= en sound_power_intensity_precision; absolute_pressure_pa= en sea_water_density static_pressure_kpa= o static_pressure_pa=, en la misma unidad
ambient_pressure_pa= en normal_air_density atmospheric_pressure_pa=, la atmósfera exterior junto a la presión estática manométrica del conducto
environmental_ratio_from_absorption(absorption_area_m2=), running_rms_decay_time(integration_time_s=) y verify_running_rms_decay(integration_time_s=) absorption_area= e integration_time=, la grafía del resto de sus paquetes
bending_stress(density_kg_m3=) density=, la grafía del resto de vibration
confidence= en building.insulation_coverage_factor, materials.absorption_coverage_factor, sound_absorption_coefficient_uncertainty, equivalent_area_uncertainty, practical_coefficient_uncertainty, weighted_coefficient_uncertainty, single_number_rating_uncertainty y environment.environmental_expanded_uncertainty, y UncertainValue.confidence coverage= y .coverage, la probabilidad de cobertura de la GUM; confidence queda para la confianza estadística de un intervalo, como en signals.power_spectral_density

Un DecayCurve se lee por nombre, curve.times y curve.levels, y ya no se desempaqueta como el par al que sustituyó. Los solvers FDTD conservan c y rho, que nombran los mapas en los que están escritas sus ecuaciones.

Una unidad también tiene una sola grafía. Una duración termina en _s o en _hours, un ángulo en _deg, una velocidad en kilómetros por hora en _kmh y una en nudos en _kt, una tasa de decaimiento en _db_per_s; _seconds, _degrees, _km_h, _knots, _db_s y un _h que significa horas ya no aparecen en ningún sitio de la API pública.

3.3.0 o 4.0.0rc1 4.0
vibration.phase_tolerance_degrees vibration.phase_tolerance_deg
ToneBurstResult.burst_seconds .burst_s
wind_speed_knots= en ocean_ambient_noise y wind_noise_spectrum, y AmbientNoiseResult.wind_speed_knots wind_speed_kt, la grafía que usan las velocidades de aeronaves
speed_knots= en ship_source_spectrum, y ShipTrafficSpectrum.speed_knots speed_kt
GasStream.molecular_mass, en kg/kmol GasStream.molar_mass_kg_kmol, el nombre que el catálogo de fluidos da a su molar_mass_kg_mol por mol

Una palabra se escribe entera: ref es reference en todo nombre público que la abreviaba. SPL, SEL, SNR y RMS se quedan como están, términos del oficio como L_max.

3.3.0 o 4.0.0rc1 4.0
levels_ref=, background_levels_ref= y lw_ref= en sound_power_comparison y sound_energy_comparison (3.3.0), y en sound_power_in_situ y sound_energy_in_situ (4.0.0rc1) reference_levels=, reference_background_levels= y reference_sound_power_levels=, este último como lo escribe high_frequency_sound_power_comparison
InSituSoundPowerResult.background_correction_ref, .sound_power_level_ref y .sound_energy_level_ref .reference_background_correction, y .sound_power_level_at_reference_conditions y .sound_energy_level_at_reference_conditions: los niveles con la corrección del anexo C (C2, a las condiciones meteorológicas de referencia), no los de la fuente de referencia
metrology.sensitivity(ref_signal=) reference_signal=

La designación de una norma solo aparece en un nombre donde distingue dos cosas, y entonces se escribe de una sola forma: el organismo unido a su número, al principio en una constante o una clase y al final en una función. Donde el módulo ya nombra la norma, la designación desaparece.

3.3.0 o 4.0.0rc1 4.0
sae_band_attenuation aircraft.band_attenuation_arp5534, el documento que sigue
itu_r_468_weighting electroacoustics.weighting_bs468
air_density_astm y speed_of_sound_astm, y plane_wave_frequency_range_astm (4.0.0rc1) materials.air_density_astm_e2611, speed_of_sound_astm_e2611 y plane_wave_frequency_range_astm_e2611, junto a air_density_iso10534
noise_control.VDI2081_SPECTRAL_CORRECTION noise_control.SPECTRAL_CORRECTION: el paquete no tiene otra corrección espectral de la que distinguirla, y su propio texto cita la VDI 2081 parte 2
building.EN_12354_AIR building.EN12354_AIR

Un identificador se escribe en inglés estadounidense, e in situ se escribe in_situ. Quien llama escribe cada nombre, así que center_frequency en una función y centre_frequency en la siguiente era un TypeError que había que ir a buscar. Los valores que se escriben en la llamada siguen la misma regla: una opción de un Literal, un valor por defecto, la clave de una tabla publicada y una cadena de una tupla publicada de opciones. catalogue conserva su grafía: también es una variante estadounidense, todos los nombres la escriben igual y es el formato de archivo de tus propios catálogos. Una cadena que imprime una fuente conserva lo impreso, y por eso la superficie de CNOSSOS de abajo sigue siendo "optimised brushed down concrete". Las opciones cerradas de los motores FDTD y de sus registros también son un Literal: un lado, un campo anotado, el sentido de avance de una onda plana y el eje de una fuerza, así que un comprobador de tipos rechaza free_sides="Top" antes de la ejecución; en tiempo de ejecución no cambia nada.

3.3.0 o 4.0.0rc1 4.0
materials.insitu_reflection_factor, insitu_absorption_from_reflection, insitu_absorption_coefficient, insitu_absorption_spectrum, plot_insitu_geometry e InsituAbsorptionResult in_situ_reflection_factor, in_situ_absorption_from_reflection, in_situ_absorption_coefficient, in_situ_absorption_spectrum, plot_in_situ_geometry e InSituAbsorptionResult, como ya se escribían los demás nombres in situ de la biblioteca
centre_frequency en critical_bandwidth, tonal_audibility, assess_tonal_audibility y TonalAssessmentResult center_frequency
centre= en room.filter_bandwidth y room.source_directivity_limit center=
location="centre" en las movilidades e impedancias puntuales de placas y vigas infinitas de vibration location="center"
.unfavourable_sum en WeightedRatingResult, ImpactRatingResult y AbsorptionRatingResult .unfavorable_sum
vibration.storey_fundamental_frequency(storeys), STOREY_FREQUENCY_MIN_STOREYS, STOREY_FREQUENCY_NUMERATOR_HZ, STOREY_PERIOD_COEFFICIENT_S vibration.story_fundamental_frequency(n_stories), STORY_FREQUENCY_MIN_STORIES, STORY_FREQUENCY_NUMERATOR_HZ, STORY_PERIOD_COEFFICIENT_S
storeys= y el modelo "storeys" en fundamental_period, fundamental_frequency y estimate_fundamental_frequency n_stories= y el modelo "stories"
draught= en underwater.monopole_source_level draft_m=, que además dice su unidad
procedure="aeroplane" en aircraft.effective_perceived_noise_level procedure="airplane", que sigue siendo el valor por defecto
urbanisation= en environment.outdoor_quality_objectives urbanization=
vapour_pressure_pa en las funciones de la IEC 60534-8-4 de noise_control (differential_pressure_ratio, cavitation_differential, jet_strouhal_number, stage_conditions, last_stage_differential) y en LiquidStream vapor_pressure_pa
"water_vapour_mole_fraction" en la composition de fluids.air() "water_vapor_mole_fraction"
building.DB_HR_NORMALISED_SPECTRA, environment.NORMALISED_RAILWAY_NOISE_SPECTRUM_DB y environment.NORMALISED_TRAFFIC_NOISE_SPECTRUM_DB DB_HR_NORMALIZED_SPECTRA, NORMALIZED_RAILWAY_NOISE_SPECTRUM_DB y NORMALIZED_TRAFFIC_NOISE_SPECTRUM_DB
simulation.ALUMINIUM simulation.ALUMINUM
RoadSurface.OPTIMISED_BRUSHED_DOWN_CONCRETE RoadSurface.OPTIMIZED_BRUSHED_DOWN_CONCRETE, cuyo valor sigue siendo el "optimised brushed down concrete" que imprime la tabla F-4 de CNOSSOS-EU

Una palabra también tiene una sola grafía. Un acrónimo se escribe en mayúsculas dentro del nombre de una clase, como siempre lo estuvieron EPNLResult y STIResult; Ecma, que es el nombre que la organización se da a sí misma y no un acrónimo, es la excepción (EcmaLoudness). mic, lab y std se escriben enteros. Un recuento es n_<plural>, y un límite sobre uno, min_n_ o max_n_ (min_n_records, max_n_arrivals); una duración nombra su magnitud antes que su unidad, nunca la unidad sola (exposure_duration_years, duration_s, period_hours), con el minuto escrito entero (assessment_period_minutes) porque un _min final es un mínimo, y un número de clase, un eje, un número de decimales y una longitud contada en muestras no son recuentos. minimum y maximum se escriben min y max en todo nombre público, MIN y MAX en una constante y Min y Max en una clase, como los escriben numpy, SciPy, scikit-learn y Matplotlib, términos consagrados incluidos: los niveles máximo y mínimo Lmax y Lmin son max_level y min_level (nunca un max_db a secas), el máximo por intervalo (Takt) de DIN 45669-1 y DIN 4150-2 es TAKT_MAX_FACTOR y la reconstrucción de fase mínima es min_phase. Una cota de confianza es confidence_lower o confidence_upper. Una función que lee una señal temporal la toma primero, como x, el nombre que ya usaban octave_filter(x, fs) y el resto de funciones de señal; llamada por posición, no cambia nada. Los nombres de la raíz de la 3.3.0 que están entre estos aparecen en la tabla de los nombres que ya no están.

3.3.0 o 4.0.0rc1 4.0
building.DbHrAssessment, DbHrCheck, DbHrGlobalIndexResult y DbHrRequirement, noise_control.HvacWarning, underwater.StrikeSelSpectrum DBHRAssessment, DBHRCheck, DBHRGlobalIndexResult, DBHRRequirement, HVACWarning, StrikeSELSpectrum
el módulo building.measurement.lab_insulation building.measurement.laboratory_insulation; importar de building no cambia
HMLRatingResult.subject_h, .subject_m y .subject_l .subject_high, .subject_medium y .subject_low, los valores por sujeto junto a high, medium y low
.std en TrendTestResult y StationarityTestResult, TimeDelayResult.delay_std .standard_deviation, .delay_standard_deviation
StationarityTestResult.count .trend_statistic, el statistic de la prueba de tendencia que ejecutó
num_points= en verify_filter_class, y FilterComplianceResult.num_points n_points
AnpAircraft.num_engines y PerformanceAircraft.engines ANPAircraft.n_engines y PerformanceAircraft.n_engines
blade_count= en fan_sound_power, y el blades de blade_passing_frequency n_blades
count= en precision_positions n_positions=
count= en circular_duct_cut_on y rectangular_duct_cut_on, y WestonRegimeBoundaries.mode_count n_modes
count= en diffuser_sound_power n_devices=
harmonics= en gear_mesh_frequencies y blade_pass_frequencies, y el count de FaultFrequencyResult.harmonics n_harmonics
SawtoothBurstTest.burst_count .n_bursts
room.MAXIMUM_DIRECTIVITY_STEP_DEG, MINIMUM_BANDWIDTH_TIME_PRODUCT, MINIMUM_DETECTOR_MULTIPLE y MINIMUM_REFERENCE_DISTANCE_M, noise_control.MAXIMUM_PASSAGE_ASPECT, MINIMUM_FLOW_RATES y MINIMUM_PRESSURE_DIFFERENCE_PA, emission.MINIMUM_BACKGROUND_MARGIN_DB MAX_DIRECTIVITY_STEP_DEG, MIN_BANDWIDTH_TIME_PRODUCT, MIN_DETECTOR_MULTIPLE, MIN_REFERENCE_DISTANCE_M, MAX_PASSAGE_ASPECT, MIN_FLOW_RATES, MIN_PRESSURE_DIFFERENCE_PA, MIN_BACKGROUND_MARGIN_DB
OperatingLine.maximum_deviation, maximum_open_loop_gain y maximum_level_at_microphone en FeedbackStabilityResult, maximum_reduction_db= en end_reflection_loss, LoudspeakerCharacteristics.minimum_impedance, minimum_load_impedance en MicrophoneCharacteristics y MicrophoneElectrical, DiscretePointIntensityResult.minimum_positions, minimum_speed= en railway_source_power max_deviation, max_open_loop_gain, max_level_at_microphone, max_reduction=, min_impedance_ohm, min_load_impedance_ohm, min_positions, min_speed_kmh=
building.a_weighted_maximum_impact_level, standardized_maximum_impact_level, AWeightedMaximumImpactResult y StandardizedMaximumImpactResult a_weighted_max_impact_level, standardized_max_impact_level, AWeightedMaxImpactResult y StandardizedMaxImpactResult: max y min en todo nombre público, términos consagrados incluidos
room.minimum_reliable_reverberation_time y minimum_receiver_positions min_reliable_reverberation_time y min_receiver_positions
PhaseDecompositionResult.minimum_phase_response .min_phase_response
maximum_levels= en aircraft.event_level y noise_contour max_levels=
ci_lower y ci_upper en SpectralDensityResult y MultitaperSpectralDensityResult confidence_lower y confidence_upper, como en MethodBSummary
elements= en low_frequency_element_normalized_difference, y LowFrequencyElementResult.elements n_elements
orders= en slit_resonance_frequencies, y el junctions de multi_junction_adjustment n_orders= y n_junctions
open_microphones= en feedback_stability y open_microphone_correction, y FeedbackStabilityResult.open_microphones n_open_microphones
events= en sound_energy_pressure, mean_single_event_level, sound_energy_in_situ, sound_energy_reverberation y sound_energy_comparison, y .events en SoundEnergyResult y ReverberationSoundEnergyResult n_events
reflecting_planes= en measurement_positions, sound_power_pressure y sound_energy_pressure n_reflecting_planes=
.positions en DiscretePointIntensityResult, y .positions, .subset_positions y .additional_positions en PartialPowerConcentration .n_positions, .n_subset_positions y .n_additional_positions
RollingStock.axles, VehicleDescriptor.axles y el axles de rolling_sound_power n_axles
sweep_points= en verify_weighting_class, y WeightingComplianceResult.sweep_points n_sweep_points
AssumedProtectionResult.subjects .n_subjects
io.AudioFileInfo.channels y .frames .n_channels y .n_samples, las muestras por canal, como en Signal
quadrature_points= en diffuse_field_absorption, y sum_terms= en helmholtz_resonator_impedance y rectangular_duct_properties n_quadrature_points= y n_sum_terms=
repetitions= en predict_diffuser_polar_response, predicted_diffusion_spectrum, metadiffuser_diffusion_spectrum, metadiffuser_polar_response y plot_qrd_geometry, y DiffuserPolarResponse.repetitions n_repetitions
cycles= y repetitions= en signals.tone_burst, ToneBurstResult.cycles y .repetitions, y cycles= en vibration.sawtooth_burst y signal_burst_indications n_cycles y n_repetitions
trials= en metrology.monte_carlo, y MonteCarloResult.trials n_trials
el passages de silencer_self_noise, valve_style_modifier, multihole_incipient_cavitation_ratio y uniform_passage_style_modifier, y el stages de stage_level_correction n_passages y n_stages
el steps de FDTD2D.run y ElasticFDTD2D.run, y max_arrivals= en underwater.eigenrays n_steps y max_n_arrivals=
simulation.ContourProbe.samples y ContourProbe(sim=...) .n_samples, de solo lectura, y engine=
record_every= y decimate= en FDTD2D.run y ElasticFDTD2D.run, por posición o por nombre snapshot_every= y snapshot_decimation=, los nombres que dan FDTDRecording y ElasticRecording a las mismas dos cuentas, y como en ellos solo por nombre: run(400, 10, 2) es run(400, snapshot_every=10, snapshot_decimation=2)
fdtd_simulation(probes=..., snapshot_every=..., snapshot_decimation=...) fdtd_simulation(FDTDRun(..., recording=FDTDRecording(probes=..., snapshot_every=..., snapshot_decimation=...))): lo que anota una ejecución acústica es un solo registro, el recording de la ejecución, como lo de una elástica es un ElasticRecording; una ejecución sin él solo anota su eje temporal, como antes
fdtd_simulation(c, dx, duration, sources=..., ...) y elastic_fdtd_simulation(c_p, c_s, dx, duration, sources=..., rho=..., ...) fdtd_simulation(FDTDRun(c=c, dx=dx, duration_s=duration, sources=..., boundaries=simulation.FDTDBoundaries(sides=..., absorbing_layer_cells=...), ...)) y elastic_fdtd_simulation(ElasticRun(c_p=c_p, c_s=c_s, dx=dx, duration_s=duration, sources=..., rho=..., ...)): una simulación es un solo registro, con los mismos argumentos, que toma cada campo por su nombre y los comprueba todos al construirse. duration es duration_s, y los boundaries= y absorbing_layer_cells= de la ejecución acústica son ahora un solo FDTDBoundaries, como los de la elástica son un solo ElasticBoundaries; compute= se queda en la función. Un argumento mal dado se rechaza donde se escribe la ejecución, con la misma clase y las mismas palabras, salvo que una duración rechazada nombra ahora duration_s
un boundaries= de elastic_fdtd_simulation que no es un ElasticBoundaries, que fallaba dentro de la ejecución se rechaza con TypeError al construir el ElasticRun
un ElasticRecording con una sonda mal formada, un campo desconocido o repetido o una cuenta de instantáneas mal dada, que solo se rechazaba cuando elastic_fdtd_simulation lo ejecutaba; un recording= de otro tipo, que fallaba dentro de la ejecución se rechaza al construir el registro, con la misma clase y las mismas palabras, y una sonda fuera de la malla la sigue rechazando la ejecución; un recording= que no es el registro propio de la ejecución (FDTDRecording para un FDTDRun, ElasticRecording para un ElasticRun) lanza TypeError nombrándolo al construir la ejecución
sidebands= en gear_mesh_frequencies y induction_motor_frequencies, el poles, el rotor_bars y el slot_harmonics de induction_motor_frequencies, y lobe_orders= en blade_pass_frequencies n_sidebands, n_poles, n_rotor_bars, n_slot_harmonics y n_lobe_orders
years= en hearing.nipts y htlan y en vibration.injury_risk y multiple_shock_assessment, y .years en los resultados de la ISO 1999 (NiptsResult y HtlanResult en la 3.3.0) y en MultipleShockResult exposure_duration_years: una duración nombra su magnitud antes que su unidad
environment.NoisePhase.hours y hours= en evaluation_period_level; hearing.Task.duration_range y .duration_samples, en horas duration_hours; .duration_range_hours y .duration_observations_hours, porque un final en _samples se lee como un número de muestras
seconds= en room.sweep_signal, inverse_filter y shaped_sweep_signal, en electroacoustics.synchronized_sweep_signal y swept_sine_distortion, en signals.noise_signal y en speech.stipa_signal; duration= en room.image_source_rir, SweptSineDistortionResult.duration, y io.Signal.duration e io.AudioFileInfo.duration (4.0.0rc1); flat_duration=, leading_duration= y trailing_duration= en materials.adrienne_window, StationarityTestResult.segment_duration y PileStrikeResult.pulse_duration duration_s, la grafía que ya tenían las demás duraciones en segundos, y flat_duration_s=, leading_duration_s=, trailing_duration_s=, .segment_duration_s y .pulse_duration_s: una duración termina en su unidad
hours= en environment.lden y ldn period_hours=, que pasa a ser keyword-only
assessment_period_min= en environment.impulse_prominence, y ImpulseProminenceResult.assessment_period_min assessment_period_minutes: un _min final se lee como un mínimo (f_min), así que el minuto se escribe entero, como la hora
ReportMetadata.source_positions y .receiver_positions .n_source_positions y .n_receiver_positions
signal_in= en loudness_ecma, tonality_ecma, roughness_ecma, fluctuation_strength_ecma y fluctuation_strength; signal= en loudness_moore_glasberg_time, en las medidas de distorsión y de ruido de electroacoustics (thd, thd_plus_noise, sinad, weighted_thd, harmonic_analysis, harmonic_distortion, dynamic_range, idle_channel_noise, modulation_distortion, difference_frequency_distortion, total_difference_frequency_distortion, dynamic_intermodulation_distortion), en impulsive_sound_adjustment y sound_pressure_level_history, en las funciones de vibración humana (running_rms, mtvv, vibration_dose_value, motion_sickness_dose_value, crest_factor, apply_weighting, apply_band_limiting) y en room.plot_excitation x
tone_freq= en tone_to_noise_ratio y prominence_ratio tone_frequency=, que, como resolution_hz=, pasa a ser keyword-only

Una elección se escribe igual allí donde se ofrece. Un conjunto de bandas es el entero fraction que ya recibían OctaveFilterBank, decay_curve y sound_intensity, 3 para tercios de octava y 1 para octavas; las palabras "third", "third-octave", "one-third-octave" y "octave" se rechazan, y una tabla que se lee por conjunto de bandas se indexa por el mismo entero. Un campo libre, uno difuso y uno de presión se escriben "free", "diffuse" y "pressure". Una ponderación frecuencial se elige con weighting, y la señal sin ponderar se escribe "Z" allí donde se ofrece: en las ponderaciones del nivel sonoro es la ponderación Z de IEC 61672-1, y en los demás casos es la respuesta que la norma deja sin ponderar, como la sola limitación de banda del medidor de vibraciones de DIN 45669-1.

3.3.0 o 4.0.0rc1 4.0
band= en field_incidence_correction, mass_law_transmission_loss, single_panel_transmission_loss, double_wall_transmission_loss, orthotropic_transmission_loss, short_pulse_mean_square_force, tapping_force_spectrum, covering_improvement, a_weighted_maximum_impact_level y cylindrical_shell_modal_density, y .band en TappingForceResult y AWeightedMaximumImpactResult fraction= y .fraction, 3 o 1
bands= en weighted_rating, weighted_impact_rating, SoundReductionResult.rating, facade_sound_reduction, normalized_flanking_level_difference, normalized_flanking_impact_level, calculated_sound_reduction_index, reciprocity_impact_level, in_situ_element, detailed_airborne_prediction y detailed_impact_prediction fraction=; None sigue leyendo el conjunto de bandas de los valores donde lo hacía
band_type= en sound_power_intensity, sound_power_intensity_points, position_count_factor y determination_standard_deviation fraction=
bandwidth= en tapping_machine_force_level_estimate fraction=
building.HEAVY_IMPACT_A_WEIGHTING["third"] y ["octave"] [3] y [1]
"free-field" y "diffuse-field" en hearing.reference_threshold, y en hearing.FIELDS "free" y "diffuse"
curve= en filters.weighting_filter y WeightingFilter, WeightingFilter.curve y WeightingComplianceResult.curve weighting= y .weighting
weighted= en broadcast.quasi_peak_meter, y QuasiPeakResult.weighted weighting="468" (por defecto) o weighting="Z", y .weighting
weighting=None en signals.ln_levels y sel weighting="Z", ahora por defecto
building.PathContribution.fraction, la parte de la energía transmitida que lleva un camino .energy_fraction, para que fraction nombre solo un conjunto de bandas
building.DetailedAirborneResult.fractions y DetailedImpactResult.fractions, la parte de la energía que lleva cada camino en cada banda .energy_fractions

Cada nombre público tiene una sola dirección

Sección titulada «Cada nombre público tiene una sola dirección»

Unos pocos nombres se podían importar desde un segundo módulo en la 3.3.0 o en la 4.0.0rc1, o desde un módulo que listaba algo que su paquete no publicaba, y la base de datos ANP ponía un nombre privado en dos constructores. Cada nombre tiene ahora una sola dirección, la que devuelve el resolvedor de más arriba, y ninguno es privado:

3.3.0 o 4.0.0rc1 4.0
vibration.partial_exposure vibration.daily_exposure, la función de la que era un segundo nombre. Llamada con el valor y la duración de una sola operación, devuelve la exposición parcial Ai(8) de esa operación, y el número no se mueve
las valoraciones ISO 717 que listaba building.measurement.insulation: weighted_rating, weighted_impact_rating, sus formas _extended, weighted_impact_improvement, impact_improvement_adaptation_term y los cuatro resultados de valoración building.weighted_rating y los demás, definidos en building.measurement.ratings
LowFrequencyProcedure, que listaba building.measurement.insulation building.LowFrequencyProcedure, definido en building.measurement.low_frequency
los trasdosados del anexo D de la ISO 12354-1 que listaba building.prediction.resilient_layers: lining_improvement, lining_improvement_in_situ, lining_resonance_frequency, weighted_lining_improvement, LiningImprovementResult building.lining_improvement y los demás, definidos en building.prediction.linings
emission.DeclarationForm; Grade y Surface, que listaba emission.sound_power; EQFilterType, que listaba filters.equalizer (metrology.equalizer en la 3.3.0) nada que importar: ningún alias de tipo es público. Pasa la cadena que toma el parámetro, por ejemplo form="single-number", y la referencia de la API muestra el Literal[...] de cada parámetro donde antes estaba el alias
BASIC_METHOD_MAX_CREST_FACTOR, que listaba vibration.human.exposure no se publica. vibration.crest_factor avisa por encima de 9, el factor de cresta hasta el que la ISO 2631-1 6.2.2 da por suficiente el método básico
REFERENCE_IMPEDANCE, REFERENCE_AREA y REFERENCE_SOUND_POWER de emission.vibration_sound_power, un módulo sin __all__ cuyo paquete nunca los publicó no se publican. Los 400 N·s/m³ y el 1 m² son los valores por defecto de reference_impedance= y reference_area= en emission.radiated_sound_power_level, y el 1 pW es metrology.REFERENCE_VALUES["gas"]["sound_power"].value
AnpAircraft(..., _database=db) y aircraft._database ANPAircraft(..., database=db) y aircraft.database, que sigue fuera del repr y de las comparaciones
AnpDatabase(..., performance=...) (4.0.0rc1) sin performance=, cuyo tipo no publicaba nadie: aircraft.load_anp_database lee las tablas de actuaciones de una exportación, y una base de datos construida a mano vuela perfiles de punto fijo
from phonometry import building, vibration
# ISO 5349-2 E.3: la exposición parcial de la desbrozadora, 4,6 m/s² durante 2 h
print(round(vibration.daily_exposure(4.6, 2 * 3600.0), 1))
print(callable(building.weighted_rating), callable(building.lining_improvement))
print(hasattr(vibration, "partial_exposure"))
# 2.3
# True True
# False

Una función se nombra por lo que devuelve, una sola vez

Sección titulada «Una función se nombra por lo que devuelve, una sola vez»

Un cálculo se nombra por la magnitud que devuelve, y un cálculo tiene un solo nombre. Una unidad se queda en el nombre de una función solo donde esa magnitud se escribe en más de una unidad (peak_velocity_from_kb_mm_s, air_power_attenuation_per_m); un nivel, una corrección, un índice o una frecuencia no la lleva, porque solo se da en decibelios o en hercios. La raíz de la suma de cuadrados de incertidumbres independientes es una sola función, metrology.combined_standard_uncertainty, la imprima la norma que la imprima, y la probabilidad de cobertura de una incertidumbre expandida se escribe coverage allí donde se pide.

3.3.0 o 4.0.0rc1 4.0
environment.combined_standard_uncertainty(contributions) metrology.combined_standard_uncertainty(contributions), con la misma firma y el mismo número; ahora rechaza un par (u, c) con u negativa
noise_control.combine_stage_levels(80.0, 74.0), noise_control.combine_internal_levels(trim, expander) noise_control.combined_stage_level([80.0, 74.0]), noise_control.combined_internal_levels([trim, expander]): los niveles llegan como una sola secuencia, como los toma cualquier otra suma energética
building.energy_average_level(levels, 0), room.directivity_energy_average(levels, 0) axis=0, por su nombre
materials.PUBLISHED_AIR materials.ABSORBER_AIR, el aire seco a 20 °C que los modelos de absorbentes usan por defecto, con los mismos valores. El prefijo PUBLISHED_ es de los catálogos, y el nombre ya no atribuye ese aire al modelo de Johnson-Champoux-Allard, cuyo libro imprime otro
metrology.combine_uncertainty(model, quantities) metrology.uncertainty_propagation(model, quantities), con los mismos argumentos
metrology.expanded_uncertainty(result, 0.95) result.expanded(0.95), el método del resultado que recibía
environmental.expanded_uncertainty(u, confidence=0.95), la de la ISO 1996-2, que el primer nivel de la 3.3.0 publicaba como environmental_expanded_uncertainty environment.environmental_expanded_uncertainty(u, coverage=0.95), con el mismo número: 2,4 dB para una u de 1,2 dB. El expanded_uncertainty de primer nivel de la 3.3.0 era otra función, la de la ISO 12999-1, que da 2,352 dB para la misma u; la tabla de los nombres que ya no están dice adónde fue
coverage_factor(0.95, one_sided) en el primer nivel de la 3.3.0 building.insulation_coverage_factor(0.95, one_sided=...), el factor de la ISO 12999-1 al que remitía. metrology.coverage_factor(coverage, dof) es otra función, el factor GUM de la t de Student, que da 1,96 a dos decimales para el 95 % e infinitos grados de libertad y no tiene forma unilateral

Los nombres de la raíz de la 3.3.0 que esto renombra o retira (combine_uncertainties, combine_uncertainty, expanded_uncertainty, combine_linings, combine_subareas, combine_partial_exposures, combine_age_and_noise, air_attenuation_m, attenuation_from_alpha y air_attenuation_coefficient) están en la tabla de los nombres que ya no están, al final de esta página.

from phonometry import metrology, noise_control
# ISO 1996-2:2017 Tabla G.2, los cinco productos c_j u_j de una hora junto a una carretera
print(round(metrology.combined_standard_uncertainty([0.59, 0.3, 2.0, 0.40, 0.38]), 2))
print(round(noise_control.combined_stage_level([80.0, 80.0]), 2))
# 2.18
# 83.01

Un nivel o una diferencia de niveles no lleva sufijo de unidad

Sección titulada «Un nivel o una diferencia de niveles no lleva sufijo de unidad»

Un nivel y una diferencia de niveles están en decibelios por definición (un nivel de sonoridad está en fonios), así que un nombre público cuyo núcleo es uno de ellos no lleva _db, sea un parámetro, un campo, una propiedad, un método o una constante. El núcleo es el último sustantivo del nombre, pasadas las palabras que lo califican por detrás (una banda, una ponderación frecuencial, before o after, max o min): un nivel, una pérdida, un aislamiento, una reducción, un rechazo, una diferencia, una mejora, una atenuación de un solo valor, una corrección, un ajuste, un índice, el término de adaptación espectral de la ISO 717, un desplazamiento o un exceso del nivel que el nombre nombra (level_shift), o el símbolo impreso de uno de ellos. Un nombre cuyo núcleo no dice decibelios conserva el sufijo: una tolerancia, un margen, una incertidumbre, una desviación, un escalón, una pendiente o una tasa (tolerance_db, background_margin_db, expanded_uncertainty_db, slope_db_per_decade, attenuation_db_per_m). La tabla de un cuaderno sigue mostrando en decibelios un número con ese nombre, ahora leídos de su núcleo, y un nivel de sonoridad en fonios; un indicador, un texto, un factor complejo o un registro con uno de esos nombres no muestra unidad, y un número que el núcleo leería mal (el índice de reflexión de la EN 1793-5, el A_eta de la IEC 60534-8-3) muestra la suya. Casi todos los nombres que esto renombra son posteriores a la 4.0.0rc1; los que se publicaron son estos.

3.3.0 o 4.0.0rc1 4.0
MicrophoneCharacteristics.sensitivity_level_db, diffuse_field_sensitivity_level_db, directivity_index_db, equivalent_noise_level_db, noise_band_levels_db, max_spl_db y distortion_spl_db; MicrophoneNoise.equivalent_level_db, MicrophoneOverload.spl_db, MicrophoneDirectivity.index_db sensitivity_level, diffuse_field_sensitivity_level, directivity_index, equivalent_noise_level, noise_band_levels, max_spl, distortion_spl; equivalent_level, spl, index
LoudspeakerCharacteristics.sensitivity_level_db, reference_level_db, directivity_index_db y spl_db, spl_db= en loudspeaker_characteristics, LoudspeakerDirectivity.index_db sensitivity_level, reference_level, directivity_index, spl, spl=, index
QuasiPeakResult.level_db; level_db= en stipa_signal y fluctuation_strength_am_noise level, level=
WindowMetricsResult.scalloping_loss_db y worst_case_processing_loss_db, SynchronousAverageResult.noise_reduction_db, ResampledSignalResult.stopband_attenuation_db y stopband_attenuation_db= en resample_signal scalloping_loss, worst_case_processing_loss, noise_reduction, stopband_attenuation, stopband_attenuation=
EmissionPressureResult.level_db, measured_level_db, background_correction_db y local_correction_db, los mismos tres parámetros de emission_sound_pressure_level, measured_level_db y background_level_db en background_noise_correction_at_workstation, local_correction_db en grade_from_local_correction, environmental_correction_db y directivity_index_db= en environmental_ratio_from_k2 y environmental_ratio_from_absorption level, measured_level, background_correction, local_correction, background_level, environmental_correction, directivity_index=
noise_control.MODAL_FILTER_ATTENUATION_DB MODAL_FILTER_ATTENUATION
emission.MAX_K3_DB y GRADE_2_MAX_K3_DB, el tope de la corrección ambiental local y su cota del grado 2 MAX_K3, GRADE_2_MAX_K3
sound_reduction_index_db en environment.airborne_insulation_rating sound_reduction_index
from phonometry import signals
metrics = signals.window_metrics("hann")
print(round(metrics.scalloping_loss, 2), round(metrics.worst_case_processing_loss, 2))
# 1.42 3.18

Un nombre que ponía _db tras palabras que sólo lo califican (corrected_db, floor_db, threshold_db, mean_db) decía la unidad de un número y nunca qué es ese número. Cada uno lleva ahora el sustantivo de lo que guarda. Un nivel toma level o levels y pierde luego su _db por la regla de la sección anterior (threshold_level, corrected_levels, emission_levels), una diferencia de niveles toma su propio sustantivo (floor_level_difference, mean_attenuation, min_isolation) y cualquier otra magnitud conserva _db tras su sustantivo (fixture_uncertainty_db, lower_tolerance_db, prominence_limit_db). Un nombre sin decibelios toma también el sustantivo de su magnitud: una tolerancia es un límite que un valor tiene que respetar, y ningún valor tiene que respetar el ± 50 % que ISO 4866 D.2 considera típico de una predicción empírica de la frecuencia fundamental de un edificio, así que se llama error. La mayoría de estos nombres son posteriores a 4.0.0rc1; los que se publicaron son estos.

3.3.0 o 4.0.0rc1 4.0
psychoacoustics.ToneAssessment.criterion_db prominence_limit_db
signals.WindowMetricsResult.highest_sidelobe_db highest_sidelobe_level
broadcast.KWeightingResponse.shelf_db y highpass_db shelf_magnitude_db y highpass_magnitude_db, junto a magnitude_db
signals.LifterResult.liftered_db liftered_spectrum_db, junto a spectrum_db
operating_db= en emission.total_standard_deviation sigma_omc_db=, el nombre que toda función de potencia sonora da a la desviación típica de las condiciones de funcionamiento y montaje
polar_db de electroacoustics.MicrophoneCharacteristics y electroacoustics.LoudspeakerCharacteristics polar_response_db
vibration.EMPIRICAL_FREQUENCY_TOLERANCE EMPIRICAL_FREQUENCY_ERROR, el mismo 0,5, junto a la empirical_frequency_bounds que lo aplica
-31.5
from phonometry import emission, signals
print(round(signals.window_metrics("hann").highest_sidelobe_level, 1))
print(emission.total_standard_deviation(1.5, sigma_omc_db=2.0))
# 2.5

Un módulo nunca queda oculto tras una función de su mismo nombre

Sección titulada «Un módulo nunca queda oculto tras una función de su mismo nombre»

Veintitrés módulos de la 4.0.0rc1 compartían nombre con la función que su paquete publicaba: signals/correlation.py estaba junto a signals.correlation(). El atributo del paquete es la función, así que import phonometry.signals.correlation as m ligaba la función, signals.correlation.time_delay lanzaba AttributeError y sólo from phonometry.signals.correlation import time_delay llegaba al módulo. Todos esos módulos son ahora privados. La función conserva su nombre, cada nombre que el paquete publicaba desde el módulo conserva su dirección, y lo único que desaparece es el import a través de la ruta del fichero:

4.0.0rc1 4.0
from phonometry.signals.correlation import time_delay from phonometry.signals import time_delay
from phonometry.fluids.air import air from phonometry.fluids import air, o fluids.air(...) tras from phonometry import fluids
broadcast.program_loudness, emission.sound_power_anechoic, emission.sound_power_in_duct, emission.sound_power_in_situ, emission.sound_power_intensity, emission.sound_power_intensity_points, emission.sound_power_reverberation, fluids.air, materials.absorbers.airflow_resistance, noise_control.duct_path, psychoacoustics.quality.fluctuation_strength, psychoacoustics.quality.fluctuation_strength_ecma, psychoacoustics.quality.roughness_ecma, psychoacoustics.quality.tonality_ecma, psychoacoustics.quality.tone_audibility, room.crowd_noise, room.impulse_response, signals.cepstrum, signals.correlation, signals.envelope, underwater.propagation.seabed_reflection, vibration.structural.junction_transmission, vibration.structural.radiation_efficiency como rutas de módulo el paquete que precede al último punto, que publica la función y sus compañeras: from phonometry.room import impulse_response, mls_impulse_response
los números que esos módulos guardaban para sí: los umbrales y las duraciones de bloque de broadcast.program_loudness (ABSOLUTE_GATE, RELATIVE_GATE, BLOCK_DURATION, BLOCK_OVERLAP, SHORT_TERM_DURATION, MAX_METER_STEP, LRA_RELATIVE_GATE, LRA_PERCENTILES), DEFAULT_SELF_NOISE_FLOOR de noise_control.duct_path, y SIGMA_NARROWBAND_LEVEL y COVERAGE_FACTOR_90 de psychoacoustics.quality.tone_audibility no se publican, como antes: sus paquetes nunca los recogieron. Cada uno sale del documento que sigue su módulo, y la función que lo lee lo aplica o lo toma como valor por defecto de self_noise_floor=, sigma_level_db= o coverage_factor=. El paso de 0,1 s es el periodo de la frecuencia de actualización de 10 Hz que exige la EBU Tech 3341, y el suelo de 0 dB es el valor por defecto de la hoja de cálculo de conductos de Architectural Acoustics de Long
los umbrales de prominencia PROMINENT_TONALITY_TU_HMS, PROMINENT_ROUGHNESS_ASPER y PROMINENT_FLUCTUATION_STRENGTH_VACIL de los módulos de la ECMA-418-2 psychoacoustics.PROMINENT_TONALITY_TU_HMS, psychoacoustics.PROMINENT_ROUGHNESS_ASPER y psychoacoustics.PROMINENT_FLUCTUATION_STRENGTH_VACIL_HMS, el último con el _HMS de su unidad, porque psychoacoustics publica también la intensidad de fluctuación de Osses en vacil a secas. Ninguna función los aplica: compara tú el resultado. El apartado 6.3 de la ECMA-418-2 considera prominente una tonalidad cuando, en un sonido estacionario, specific_tonality supera 0,4 tu_HMS en un máximo local cuya entrada de tonal_frequencies cae entre las frecuencias centrales situadas un Bark_HMS por debajo y por encima, o, en un sonido no estacionario, cuando tonality supera 0,4 tu_HMS. El apartado 7.2 considera prominente una aspereza cuando roughness supera 0,2 asper, y el apartado 9.2 una intensidad de fluctuación cuando fluctuation_strength supera 0,2 vacil_HMS

En la 3.3.0 varios de ellos vivían en otro sitio (metrology/correlation.py, psychoacoustics/tone_audibility.py); también allí la respuesta es importar del paquete.

signals.test_signals (4.0.0rc1) también es privado, por otro motivo: pytest recoge un módulo cuyo nombre empieza por test_, y el prefijo es de los ficheros de test. Cada función que contenía conserva su dirección en signals., así que from phonometry.signals.test_signals import noise_signal es from phonometry.signals import noise_signal.

Los alias de tipo que definían esos módulos se fueron con ellos, y ya no hay ruta pública que llegue a ellos: PrecisionSurface, PrecisionArray y PrecisionRoom de emission.sound_power_anechoic, MicrophoneShield de emission.sound_power_in_duct, Grade y BandType de emission.sound_power_intensity, y DeterminationGrade y BandType de emission.sound_power_intensity_points. Anota con el Literal que representaba cada uno: Literal["sphere", "hemisphere"] para PrecisionSurface, y así con los demás. BandType nombraba un conjunto de bandas, que ahora es el entero fraction: Literal[1, 3].

from phonometry import room, signals
print(callable(signals.correlation), callable(signals.time_delay))
print(callable(room.impulse_response), callable(room.mls_impulse_response))
# True True
# True True

Un módulo sin __all__ no dice cuáles de sus nombres son públicos, así que una constante que definía para su propio uso parecía tan pública como sus funciones, y algunas llegaron a las guías y a los scripts por la ruta completa del módulo. Todo módulo público lista ahora lo que define y su paquete publica, y lo demás que define lleva un guion bajo delante. Estos nombres se alcanzaban así en la 3.3.0 o en la 4.0.0rc1 y ya no:

3.3.0 o 4.0.0rc1 4.0
OCTAVE_BANDS, NC_INDICES y NC_CURVES de room.noise_criteria (room.room_noise en la 3.3.0) room.NC_OCTAVE_BANDS_HZ, room.NC_RATINGS y room.NC_CURVE_LEVELS, publicados con su unidad: las diez bandas de la tabla 1 de la ANSI/ASA S12.2, sus doce designaciones y sus niveles por banda
BAND_CENTERS, BAND_IMPORTANCE, REFERENCE_INTERNAL_NOISE y VOCAL_EFFORTS de speech.sii (hearing.sii en la 3.3.0) speech.sii_procedure("one-third-octave"), cuyos frequencies, band_importance e internal_noise son los mismos arrays, y speech.standard_speech_spectra().vocal_efforts
NIPTS_FREQUENCIES de hearing.noise_induced_hearing_loss las frequencies del resultado de hearing.nipts(...)
VALIDATED_YEARS, VALIDATED_FRACTILES y VALIDATED_L_EX_MAX del mismo módulo no se publican. nipts y htlan avisan fuera de los 1 a 40 años, los fractiles de 0,05 a 0,95 y los 100 dB que valida la ISO 1999
OCTAVE_BANDS de noise_control.hvac y de room.enclosed_space_absorption no se publican: cada uno es el eje de bandas por defecto de sus funciones, y todo resultado lleva sus frequencies
SPEED_OF_SOUND, AIR_ATTENUATION y PUBLISHED_AIR_CONDITION (DEFAULT_AIR_CONDITION en la 3.3.0) de room.enclosed_space_absorption no se publican: los 345,6 m/s por defecto de speed_of_sound=, y las seis condiciones que admite air_condition=, que su docstring enumera, con "20C_50-70" como la que recomienda el apartado 4.3
REFERENCE_VELOCITY, REFERENCE_FORCE, REFERENCE_SOUND_POWER y FREE_VELOCITY_REFERENCE de building.measurement.structure_borne_power (building.structure_borne_power en la 3.3.0), y REFERENCE_PRESSURE de environment.assessment.impulsive_sound (environmental.impulsive_sound en la 3.3.0) el .value de la entrada de metrology.REFERENCE_VALUES de la que se leía cada uno, porque la entrada es un registro y no un número: ["solid"]["velocity"].value (1 nm/s), ["solid"]["force"].value (1 µN), ["gas"]["sound_power"].value (1 pW), ["solid"]["velocity_alternative"].value (los 50 nm/s de la nota b de la tabla 3, la referencia de velocidad libre de la ISO 9611) y ["gas"]["sound_pressure"].value (20 µPa)
REFERENCE_MOBILITY y CHARACTERISTIC_PLATE_MOBILITY de building.measurement.structure_borne_power (building.structure_borne_power en la 3.3.0), y REFERENCE_PLATE_MOBILITY de building.prediction.installed_structure_borne (building.installed_structure_borne en la 3.3.0) no se publican. REFERENCE_MOBILITY es la movilidad de referencia de 1 m/(N s) del apartado 5 de la EN 15657, que las funciones aplican en sus fórmulas (15), (17) y (18); la movilidad de la placa es el valor por defecto de characteristic_mobility= y de plate_mobility=
SPEED_OF_SOUND, AIR_DENSITY, REFERENCE_FREQUENCY, REFERENCE_LENGTH y MAX_RADIATION_FACTOR de building.prediction.detailed_model no se publican. El aire es building.EN12354_AIR, que lleva los 340 m/s y los 1,29 kg/m³
los coeficientes, límites y valores por defecto de environment.assessment.impulsive_sound (environmental.impulse_prominence y environmental.impulsive_sound en la 3.3.0): PROMINENCE_COEFFS, ADJUSTMENT_SLOPE, ADJUSTMENT_THRESHOLD, ONSET_RATE_LIMIT, DEFAULT_ASSESSMENT_PERIOD_MIN, ONSET_GRADIENT_LIMIT, TIME_WEIGHTING_F_TAU, MERGE_GAP, SAMPLE_INTERVAL_RANGE, DEFAULT_SAMPLE_INTERVAL, HIGHLY_IMPULSIVE_LIMIT no se publican: cada uno lo aplica impulse_prominence o impulsive_sound_adjustment, y los dos valores por defecto son los de dt= (20 ms) y assessment_period_minutes= (30 min)
las constantes del anexo C de vibration.human.multiple_shock (vibration.multiple_shock_vibration en la 3.3.0): MZ_MALE, MZ_FEMALE, DOSE_AMPLITUDE_FACTOR, DOSE_EXPONENT, GRAVITY, ULTIMATE_STRENGTH_INTERCEPT, STRENGTH_AGE_SLOPE_MALE, STRENGTH_AGE_SLOPE_FEMALE, WEIBULL_MALE, WEIBULL_FEMALE, RISK_THRESHOLDS_MALE, RISK_THRESHOLDS_FEMALE no se publican: las funciones toman sex= y aplican la pareja que nombra. compression_dose(..., mz=) toma por defecto 0,029, el valor masculino de la fórmula C.2; pasa 0,025 para el femenino
DEFAULT_HEADWIND_KT y APPROACH_WEIGHT_FRACTION de aircraft.flight_performance no se publican: los 8 kt por defecto de Aerodrome(headwind_kt=), y el 0,9 del peso máximo de aterrizaje con el que se vuela la aproximación
STANDARD_ATMOSPHERIC_PRESSURE de materials.resilient.dynamic_stiffness (materials.dynamic_stiffness en la 3.3.0) no se publica: los 0,1 MPa por defecto de static_pressure_pa=
REFERENCE_SPACING de emission.intensity_compliance no se publica: la separación nominal de micrófonos de 25 mm de la Tabla 2 de IEC 61043, el valor por defecto de spacing_m= de residual_index_limits y verify_intensity_class
DISTRIBUTIONS de metrology.uncertainty no se publica: metrology.Quantity rechaza un distribution= fuera de "gaussian", "rectangular", "triangular" y "u-shaped" y nombra las cuatro
CIRCULAR_EIGENVALUES, PLANE_WAVE_EIGENVALUE y warn_above_plane_wave_limit de noise_control.duct_modes noise_control.circular_duct_cut_on y noise_control.plane_wave_limit; los resultados del silenciador y del recorrido de conducto lanzan ellos mismos PlaneWaveWarning por encima del límite
WALL_ORDER de room.image_source no se publica: un absorption= por pared va en el orden x0, xL, y0, yL, z0, zL
MAX_ENUMERATED_LATTICE de room.modes, SAMPLE_RATE de speech.objective_intelligibility (hearing.objective_intelligibility en la 3.3.0) no se publican: un límite de la retícula que room_modes indica cuando rechaza el cálculo, y los 10 kHz a los que remuestrea speech.stoi
AUDIBILITY_THRESHOLD_SONE_HMS de psychoacoustics.loudness_ecma (3.3.0) psychoacoustics.AUDIBILITY_THRESHOLD_SONE_HMS; psychoacoustics.loudness.ecma.AUDIBILITY_THRESHOLD_SONE_HMS, su dirección en la 4.0.0rc1, se sigue importando. Ninguna función lo aplica: el apartado 5.1.9 de la ECMA-418-2 considera audible una señal cuando su sonoridad básica total, la sonoridad básica específica sumada en las 53 bandas (fórmula 26), supera 0,01 sone_HMS, y loudness_ecma devuelve ese total bloque a bloque como basis_loudness_vs_time, el campo con el que se compara hasta su last_evaluated_block; su loudness es la N de la fórmula 117, no esa suma
J1_FIRST_ZERO de electroacoustics.piston desaparece: nadie lo leía. Es scipy.special.jn_zeros(1, 1)[0]
critical_bandwidth de environment.sources.wind_turbine (environmental.wind_turbine_noise en la 3.3.0) el critical_bandwidth del WindTurbineTonalityResult. environment.critical_bandwidth es otra banda, la de la ISO 1996-2
reference_sound de psychoacoustics.quality.sharpness (psychoacoustics.sharpness en la 3.3.0) no se publica: la biblioteca construye la señal de ensayo del apartado 6 de la DIN 45692 sólo para fijar su propia normalización. Es un ruido limitado a la banda de 920 a 1080 Hz con 60 dB: pasa signals.noise_signal(fs, duration_s) por un filtro paso banda de 920 a 1080 Hz, escálalo a 0,02 Pa de valor eficaz, y psychoacoustics.sharpness_din le da 1,00 acum
check_guidance de underwater.bioacoustics.weighting no se publica. Las funciones que toman guidance= rechazan una desconocida, y underwater.WEIGHTING_GUIDANCE nombra las conocidas

Los alias de tipo que definen estos módulos (NCMethod, EventMetric y los demás) tampoco se listan, por la regla de más arriba, y se siguen pudiendo importar como anotaciones.

from phonometry import hearing, room, speech
print(room.NC_CURVE_LEVELS[room.NC_RATINGS == 40][0][:3])
print(round(speech.sii_procedure("one-third-octave").band_importance.sum(), 6))
print(hearing.nipts(95.0, 40.0, 0.9).frequencies[:3])
# [84. 74. 64.]
# 1.0
# [ 500. 1000. 2000.]

El .plot() de cada resultado se lee ahora plot(ax=None, *, ...): primero los ejes, y todo lo demás por su nombre, language incluido. Tres no empezaban por los ejes en la 3.3.0, así que plot(ax) les entregaba los ejes al parámetro equivocado:

3.3.0 4.0
LoudspeakerCharacteristics.plot("impedance", ax) .plot(ax, quantity="impedance")
MicrophoneCharacteristics.plot("noise", ax) .plot(ax, quantity="noise")
TransferMatrix.plot(f, rho_c, ax) .plot(ax, frequencies=f, characteristic_impedance=rho_c)

Seis resultados posteriores a la 3.3.0 tomaban language por posición en la 4.0.0rc1: las cuatro valoraciones de protectores auditivos y los dos resultados de intensimetría en baja frecuencia. plot(ax, "es") sobre ellos es ahora plot(ax, language="es"), como en todos los demás.

Las funciones auxiliares plot_* públicas, que dibujan un dispositivo o una geometría en vez de un resultado, comparten ahora también una sola forma: lo que dibujan, por posición, y los ejes, el idioma y los argumentos de estilo, por su nombre, plot_x(<datos>, *, ax=None, ..., language="en", **kwargs). Diecisiete tomaban los ejes detrás de sus datos y seis los tomaban primero. plot_silencer_geometry tomaba además cada dimensión como un argumento propio; ahora toma el kind y la geometry que guarda un ReactiveSilencerResult, con las dimensiones en un solo mapeo bajo las mismas claves, de modo que el dibujo se lee como el resultado:

3.3.0 o 4.0.0rc1 4.0
vibration.plot_plate_geometry(0.8, 0.6, ax), environment.plot_barrier_geometry(ax, source_height=...) y las otras veintiuna funciones auxiliares plot_* públicas plot_plate_geometry(0.8, 0.6, ax=ax), plot_barrier_geometry(ax=ax, source_height_m=...)
noise_control.plot_silencer_geometry("expansion chamber", ax, length=0.3, chamber_area=0.04, pipe_area=0.01) plot_silencer_geometry("expansion chamber", {"length": 0.3, "chamber_area": 0.04, "pipe_area": 0.01}, ax=ax)

Un .plot() de varios paneles devuelve una tupla de ejes

Sección titulada «Un .plot() de varios paneles devuelve una tupla de ejes»

Un .plot() que dibuja más de un panel devuelve, sin ax, una tupla con sus ejes, el panel de arriba primero, donde la 3.3.0 y la 4.0.0rc1 devolvían un array de NumPy con ellos. La indexación, el desempaquetado y len() funcionan como antes; los atributos propios del array, no:

3.3.0 o 4.0.0rc1 4.0
axes = result.plot(), y luego axes.shape o axes.size len(result.plot())
result.plot().flat, result.plot().ravel() la propia tupla: for ax in result.plot()
isinstance(drawn, np.ndarray), para distinguir varios paneles de unos solos ejes isinstance(drawn, tuple)

Con ax, el gráfico dibuja un panel sobre ellos y devuelve esos ejes, como antes. Cada caso es ahora una sobrecarga tipada, así que un comprobador de tipos lee top, bottom = result.plot() como dos Axes y result.plot(ax=ax) como uno. ZwickerLoudness.plot() sin ax sigue devolviendo unos ejes para un resultado estacionario y dos para uno variable en el tiempo, algo que deciden solo los datos.

Los gráficos que dibujan sobre unos ejes polares lo dicen. PistonDirectivity, VectorChangeResult y DiffuserPolarResponse devuelven un PolarAxes, igual que DiffusionResult.plot() sin ax, DirectivityFactor.plot() en su vista "response", y LoudspeakerCharacteristics.plot() y MicrophoneCharacteristics.plot() con quantity="directivity". Esos toman un PolarAxes donde lo necesitan; matplotlib tipa como Axes simples un subplot creado con projection="polar", así que quien comprueba tipos lo entrega como typing.cast(PolarAxes, ax). DiffuserPolarResponse.plot() rechaza unos ejes cartesianos con un ValueError que nombra ax, como los demás gráficos polares, donde antes saltaba un AttributeError de matplotlib.

Un array de dimensión cero devuelve un array de dimensión cero

Sección titulada «Un array de dimensión cero devuelve un array de dimensión cero»

Una función de un número o de un array de ellos devuelve un float solo cuando todos los argumentos que deciden la forma de su resultado son números, de Python o de NumPy, y un array en cuanto uno de ellos es una secuencia o un array, donde la 3.3.0 y la 4.0.0rc1 devolvían un float para un array de dimensión cero, y un array de dimensión cero, un escalar de NumPy o un array de un elemento para números. Trescientas cincuenta y dos funciones y métodos públicos siguen la regla, entre ellos room.room_constant, room.critical_distance y fluids.sea_water_sound_speed, y vibration.evaluation_zone la sigue con la letra de una zona donde las demás dan un float, y un resultado complejo (una movilidad, una impedancia, una función de transferencia) con un complex de Python:

3.3.0 o 4.0.0rc1 4.0
room.room_constant(100.0, np.array(0.2)) devolvía el float 25.0 devuelve array(25.); float(...) o .item() da el número
emission.local_environmental_correction([0.5]) devolvía un float para cualquier entrada de un elemento, igual que emission.environmental_ratio_from_k2, emission.environmental_ratio_from_absorption, y el campo background_margin_db y la propiedad correction del WorkstationBackgroundCorrection que devuelve emission.background_noise_correction_at_workstation cada uno da un array de un elemento; para obtener un número, se pasa 0.5 y no [0.5]
electroacoustics.piston_resistance(1.0) devolvía un numpy.float64, igual que piston_reactance y piston_directivity devuelve un float de Python, sin .shape ni .dtype
building.mass_law_transmission_loss(500.0, 10.0) devolvía un array de dimensión cero, igual que otras 61 funciones y métodos que se enumeran abajo devuelve un float de Python; np.asarray(...) da un array donde haga falta
materials.absorption_coefficient(4.0, 2.0, 200.0, 11.0) devolvía un numpy.float64, igual que otras 7 que se enumeran abajo devuelve un float de Python, sin .shape ni .dtype
building.composite_transmission_loss([10.0, 2.0], [40.0, 25.0]) devolvía un array de dimensión cero, igual que building.total_structure_borne_pressure_level([30.0, 35.0]), materials.reverberation_time_uncertainty y emission.mean_single_event_level con n_events=None cada una devuelve un float cuando se reduce a un número
building.survey_service_equipment_level([30.0, 31.0, 32.0], 0.5, volume=50.0) guardaba un array de dimensión cero en l_xy y un numpy.float64 en l_xy_nt y l_xy_n los tres niveles son float de Python para lecturas sueltas
vibration.sdof_mobility(100.0, 1.0, 1.0e4, 5.0) devolvía un array complex128 de dimensión cero, igual que otras 18 funciones que se enumeran abajo devuelve un complex de Python; np.asarray(...) da un array donde haga falta
materials.membrane_impedance(500.0, surface_density=1.0) devolvía un array complejo de un elemento, igual que otras 8 funciones que se enumeran abajo devuelve un complex de Python, y un array de dimensión cero da uno de dimensión cero
building.bending_radiation_factor(500.0, critical_frequency=100.0, length1=4.0, length2=3.0) devolvía un array de un elemento, igual que otras 69 funciones y métodos que se enumeran abajo, cuya comprobación convertía un número en un array de una dimensión devuelve un float de Python, y un array de dimensión cero da uno de dimensión cero

Las funciones y los métodos que devolvían un array de dimensión cero para números son, además de building.mass_law_transmission_loss: aircraft.MeanGroundPlaneResult.height; en building, background_correction, low_frequency_level, characteristic_reception_plate_power, equivalent_blocked_force_level, equivalent_free_velocity_level, source_mobility_from_levels, structure_borne_power_level, transmission_loss_from_coefficient, coupling_term, coupling_term_force_source, coupling_term_velocity_source, installed_power_from_reception_plate, installed_structure_borne_power_level, structure_borne_pressure_level_path, structure_to_airborne_adjustment, tapping_machine_characteristic_power_level, tapping_machine_coupling_term, tapping_machine_force_level_estimate, force_pulse y typical_element_mobility; en emission, normal_intensity_from_levels, phase_mismatch_from_residual_index, residual_index_from_phase_mismatch, background_noise_correction, radiated_sound_power_level, radiation_factor, velocity_level y velocity_level_from_acceleration; en environment, air_attenuation, kurze_anderson_attenuation y EffectiveSoundSpeedProfile.speed_at; en materials, absorption_from_reflection, absorption_reference_corrected, air_density_iso10534, normalized_diffusion_coefficient, scattering_coefficient, speed_of_sound_iso10534, speed_of_sound_iso17497, standing_wave_absorption, standing_wave_ratio_from_level, standing_wave_reflection_magnitude, statistical_absorption, tube_attenuation_constant, absorption_coefficient_uncertainty, base_plate_scattering, random_incidence_absorption y specular_absorption_coefficient; signals.comb_filter_response; y en vibration, corner_transmission_coefficient, straight_transmission_coefficient, coupling_loss_factor, point_connection_coupling_loss_factor, wave_vibration_reduction_index, random_error_percent, transfer_stiffness_level, loss_factor, beam_bending_wave_speed, plate_bending_wave_speed, injected_power y phase_tolerance_deg (phase_tolerance_degrees en la 4.0.0rc1). Los que devolvían un escalar de NumPy son, además de materials.absorption_coefficient: building.surface_pressure_intensity_indicator y building.reverberation_index; environment.predicted_prominence y environment.impulse_adjustment; materials.absorption_area; room.hard_object_absorption; y vibration.ultimate_strength. Un array de dimensión cero que se dé a cualquiera de ellos devuelve un array de dimensión cero, y los valores son los mismos.

Los resultados complejos que devolvían un array de dimensión cero para números son, además de vibration.sdof_mobility: en materials, normalized_surface_impedance, normalized_surface_admittance, surface_impedance, reflection_factor, tube_wavenumber, standing_wave_reflection y standing_wave_normalized_impedance; y en vibration, sdof_receptance, sdof_accelerance, convert_frf, infinite_beam_impedance, infinite_beam_mobility, infinite_beam_moment_mobility, base_transmissibility, blocking_force_ratio, transfer_stiffness_direct, transfer_stiffness_indirect y seat_to_spine_transfer. Los que devolvían un array complejo de un elemento son, además de materials.membrane_impedance: environment.spherical_reflection_coefficient; en materials, perforated_plate_impedance, microperforated_plate_impedance y helmholtz_resonator_impedance; en noise_control, helmholtz_impedance y quarter_wave_impedance; simulation.far_field_from_contour; y underwater.reflection_coefficient. Los resultados reales que devolvían un array de un elemento son, además de building.bending_radiation_factor: en aircraft, atmospheric_adjustment, diffraction_attenuation, ground_effect_adjustment, npd_level y ANPNPDCurves.level (AnpNpdCurves.level en la 3.3.0 y la 4.0.0rc1); en building, acceleration_level, band_mode_count, bare_floor_impact_level, calculated_sound_reduction_index, direct_impact_level, direct_reduction_index, direction_averaged_level_difference, equivalent_absorption_length, fast_reverberation_correction, flanking_impact_level, flanking_impact_level_from_flanking_level, flanking_impact_level_from_normalized_difference, flanking_reduction_index, flanking_reduction_index_from_flanking_level, flanking_reduction_index_from_normalized_difference, floating_floor_improvement, forced_radiation_factor, in_situ_equivalent_absorption_length, in_situ_impact_level, in_situ_reduction_index, in_situ_total_loss_factor, in_situ_velocity_level_difference, laboratory_total_loss_factor, modal_overlap_factor, normalized_ceiling_attenuation, partition_referenced_reduction_index, plate_loss_factor, reciprocity_impact_level, resilient_mount_improvement, resonant_sound_reduction_index, short_pulse_mean_square_force, structural_reverberation_time, total_loss_factor, velocity_level_difference y vibration_reduction_index_from_flanking; electroacoustics.weighting_bs468 (itu_r_468_weighting en la 3.3.0 y la 4.0.0rc1); en emission, flow_modal_correction y in_duct_reproducibility; en environment, fresnel_number (environmental.fresnel_number en la 3.3.0) y line_source_segment_power; en hearing, earphone_reference_level, hearing_level_to_coupler_spl y reference_threshold; materials.spot_internal_loss_correction; los peak_exceedance y peak_density de metrology.PeakStatisticsResult; en noise_control, band_internal_levels, cavitation_distribution, duct_sound_power_level, flow_noise_power_level, measured_transmission_loss, open_end_reflection_coefficient, open_end_transmission_loss, substitution_insertion_loss, transmission_loss_correction y turbulent_distribution; en underwater, seawater_absorption, spreading_loss, thermal_noise_spectrum y wind_noise_spectrum; y en vibration, band_limiting_factors, beam_modal_density, cylindrical_shell_modal_density y weighting_factors. Una secuencia o un array que se dé al argumento que decide la forma, también de un elemento, devuelve el array que devolvía, y los valores son los mismos. Un argumento por banda que acompaña a las frecuencias no decide nada por sí mismo: el tiempo de reverberación estructural de building.total_loss_factor y building.equivalent_absorption_length y el tiempo de reverberación de building.plate_loss_factor (con frequency= para las dos primeras en la 4.0.0rc1), dados como una secuencia de un elemento o un array de dimensión cero junto a una frecuencia numérica, daban un array de un elemento y ahora dan un float. Sin frecuencias, hearing.reference_threshold y hearing.earphone_reference_level dan todas las bandas de su tabla, como antes.

Estas llegaron después de la 4.0.0rc1 y siguen la regla desde el principio, con un complex para números: electroacoustics.program_signal_filter; en materials, microphone_calibration_factor y apply_microphone_calibration; en metrology, microphone_acoustic_impedance, temperature_transfer_function, air_gap_series_impedance_pa_s_m3, free_field_transfer_impedance, los acoustic_impedance_pa_s_m3 y complex_equivalent_volume_m3 de ReciprocityMicrophone y los response_at y record_response_at de TimeSelectiveResponse; y en vibration, kb_weighting_response, band_limitation_response y los fitted_frf, corrected_frf y corrected_mobility de SingleModeFitResult; y con un float: en electroacoustics, band_limit_response, field_strength, field_strength_level, magnetic_flux_density, telecoil_response, AmplifierFrequencyResponse.at y los at y drive_voltage de LoopImpedance; en emission, reverberation_parameter, special_room_background_correction, air_absorption_np_per_m, free_field_absorption_correction, directionality_tolerance, inverse_square_law_tolerance, min_analyzer_bandwidth, plant_air_absorption_db_per_m, reverberation_background_correction, room_absorption_coefficient, room_constant_from_air_absorption, room_constant_from_reverberation_time, radiation_impedance_correction, reference_source_reproducibility y el sound_power_level_at de ReferenceSourceCalibration; en environment, air_power_attenuation_per_m, barrier_background_correction y redistributed_band_energies; en hearing, age_and_noise_threshold, incidence_correction y reat_expanded_uncertainty; en io, el values_at de BandedRow y de las filas de catálogo de materials, building y noise_control; en materials, power_attenuation_from_alpha, air_density_astm_e2611, speed_of_sound_astm_e2611, in_situ_absorption_from_reflection, air_absorption_correction y reproducibility_uncertainty; en metrology, max_expanded_uncertainty, los level_at y spectrum_at de RectangularPulse y los level_at y phase_deg_at de TimeSelectiveResponse; en noise_control, flow_velocity_m_s, insertion_level_difference, reverberant_surface_area_m2, screen_background_corrected_level, silencer_background_correction, silencer_sound_power_level, transmission_level_difference y velocity_pressure_pa; en room, corrected_distribution_value, floor_reference_value, level_excess, reference_distribution_value y sound_distribution_value; y en vibration, assessment_weighting_response, blast_peak_velocity_mm_s, elastic_insertion_loss, far_field_velocity_mm_s, foundation_to_floor_level_difference, ground_attenuation_coefficient_per_m, ground_transmission, impact_peak_velocity_mm_s, kb_weighted_levels, machine_count_correction, machine_hall_velocity_mm_s, material_damping_factor, passage_energy_spectral_density, predict_floor_spectrum, rescale_emission_for_speed, spectral_density_level, train_kb_fmax, train_velocity_ratio, velocity_psd_from_voltage y velocity_spectrum_um_s. Un argumento por banda junto a las frecuencias de estas, como los niveles de potencia sonora de room.sound_distribution_value, las diferencias de nivel de vibration.predict_floor_spectrum y el exponente de vibration.ground_transmission, no decide nada por sí mismo, y da un float junto a una frecuencia numérica también como una secuencia de un elemento.

Trescientos dieciséis de ellos tienen sobrecargas tipadas, así que un comprobador de tipos lee room.room_constant(100.0, 0.2) como un float y room.room_constant(100.0, alphas) como un array, sea cual sea la forma de alphas; un ArrayLike o una lista anidada se lee como la unión, que quien comprueba tipos estrecha. Las reducciones (signals.leq y los demás niveles de una señal, building.energy_average_level, room.directivity_energy_average y sus afines), cuyo resultado es un número para una entrada de una dimensión, conservan la unión y su comportamiento. Los cuatro caminos de flanco del modelo detallado de edificación (building.flanking_reduction_index, building.flanking_impact_level y sus dos formas a partir de una diferencia normalizada), cinco o seis de cuyos argumentos se difunden, y building.vibration_reduction_index_from_flanking, que difunde cinco, conservan la unión en su firma y siguen la regla al ejecutarse.

Las matrices de cuatro polos de noise_control siguen la regla con una matriz en lugar de un número. noise_control.duct_matrix(500.0, 0.3, 0.05) devolvía una pila de una matriz, de forma (1, 2, 2), igual que noise_control.shunt_matrix para una impedancia; ahora las dos devuelven la matriz (2, 2) sola para un número o un array de dimensión cero, y la pila (n_freq, 2, 2) para una secuencia o un array, también de un elemento, como antes. noise_control.cascade multiplica matrices sueltas en una matriz, lo que la 4.0.0rc1 rechazaba, y pilas en una pila, y rechaza una matriz suelta junto a una pila con un ValueError; noise_control.transmission_loss y noise_control.insertion_loss devuelven un float para una matriz suelta, donde lanzaban un IndexError, y un valor por frecuencia para una pila. matrix[np.newaxis] forma una pila de una, que da el array de un elemento que daba; los valores son los mismos.

Una frecuencia de muestreo es un float, y un recuento admite un entero de NumPy

Sección titulada «Una frecuencia de muestreo es un float, y un recuento admite un entero de NumPy»

La frecuencia de muestreo de un Signal es el float que se le dio, así que un comprobador de tipos lee sig.fs como un float, donde leía un int, y toda función que funciona a cualquier frecuencia positiva admite un float: la frecuencia que devuelve una función es la que admite la siguiente. Las funciones que necesitan un número entero de muestras por segundo siguen rechazando una fraccionaria: io.write, que escribe la frecuencia en la cabecera del archivo, las señales de prueba de electroacoustics, electroacoustics.field_strength_meter, room.image_source_rir, psychoacoustics.loudness_zwicker, psychoacoustics.sharpness_din, psychoacoustics.psychoacoustic_annoyance_from_signal y speech.stoi. vibration.evaluate_train_passage, signals.resample_signal con un Signal y el banco del método B de environment también rechazaban una frecuencia fraccionaria, con el argumento de que el banco de filtros necesitaba una entera, y no la necesita: funcionan a cualquier frecuencia.

3.3.0 o 4.0.0rc1 4.0
psychoacoustics.loudness_zwicker(x, sig.fs) pasaba la comprobación de tipos, con sig.fs leído como un int se entrega el Signal, loudness_zwicker(sig), o int(sig.fs)
io.write(path, io.Signal(x, 44100.5)) fallaba dentro de la cabecera con struct.error lanza ValueError nombrando fs, como lo hace fs=44100.5
filters.OctaveFilterBank(fs, order=2.5), room.mls_signal(10.5) y los demás recuentos que solo se comprobaban como un número funcionaban con una fracción o un booleano una fracción lanza ValueError: 'order' must be a whole number, un booleano un TypeError; se pasa el número entero
emission.sound_intensity(p1, p2, fs, spacing_m=d, fraction=1.0) funcionaba lanza TypeError, como toda fracción de banda; se pasa 1 o 3

Un recuento, una fracción de banda o un indicador admiten el entero o el valor de verdad de NumPy que admite su validador (int | np.integer[Any], BandFraction | np.integer[Any], bool | np.bool_), y los valores por banda admiten un mapeo con claves enteras ({125: 40.0}) igual que uno con claves de coma flotante. Un recuento que solo se comprobaba como un número pasa por la misma comprobación de número entero, así que se rechaza la fracción o el booleano que antes admitía, como en las filas de arriba. Un registro de resultado que valida un recuento o una fracción de banda guarda el int que lee, donde guardaba el entero de NumPy tal como se le dio.

Un parámetro que admite números rechaza un texto antes de que la llamada se ejecute

Sección titulada «Un parámetro que admite números rechaza un texto antes de que la llamada se ejecute»

Un parámetro que admite números se anotaba con el ArrayLike de NumPy, que admite cualquier str y cualquier bytes, así que signals.leq("not a signal") pasaba la comprobación de tipos de mypy y de pyright y solo la llamada lo rechazaba. Todo parámetro, campo y constructor declarado de ese tipo admite ahora NumericArrayLike: un número, una secuencia de números anidada a cualquier profundidad, o un array de NumPy, o cualquier objeto con un __array__, de tipo de dato numérico o booleano, y ningún texto. Una lista, una tupla, una lista anidada, un array de cualquier tipo de dato numérico y un Signal pasan la comprobación de tipos como antes, y las llamadas se ejecutan como se ejecutaban.

3.3.0 o 4.0.0rc1 4.0
signals.leq("not a signal") pasaba la comprobación de tipos, y la llamada lanzaba TypeError el comprobador de tipos lo rechaza, y la llamada lanza el mismo TypeError
levels: ArrayLike = load(); signals.leq(levels) pasaba la comprobación de tipos el comprobador de tipos lo rechaza, porque ArrayLike dice que puede haber un texto; se anota levels con lo que guarda, NDArray[np.float64], Sequence[float] o float
view = memoryview(samples); signals.leq(view) pasaba la comprobación de tipos el comprobador de tipos lo rechaza, como rechaza un array de ctypes u otro objeto que ofrece sus números solo por el protocolo de búfer, mientras la llamada se ejecuta como se ejecutaba; se pasa np.asarray(view)

Las etiquetas de environment.statistical_pass_by (vehicle_categories) y los sites de los resúmenes de paisaje sonoro de environment conservan ArrayLike: admiten textos.

Los veredictos son objetos de resultado, no diccionarios

Sección titulada «Los veredictos son objetos de resultado, no diccionarios»

Las tres funciones verify_* de la 3.3.0 devolvían dict[str, Any] y ahora devuelven una dataclase congelada, como cualquier otro resultado de la biblioteca. filter_class_compliance, el envoltorio público que existía solo para empaquetar el veredicto del filtro, se fue con el cambio, ya que el verificador devuelve ahora el objeto él mismo. Cada clave del diccionario es un atributo del mismo nombre, salvo passed, que es passes, y todo argumento que va detrás de aquel sobre el que trata la llamada se escribe por su nombre.

3.3.0 4.0
verify_filter_class(bank)["overall_class"] filters.verify_filter_class(bank).overall_class
verify_filter_class(bank, 4096) filters.verify_filter_class(bank, n_points=4096)
verify_weighting_class(wf)["overall_class"] filters.verify_weighting_class(wf).overall_class
verify_aircraft_noise_system(...)["passed"] aircraft.verify_aircraft_noise_system(...).passes
filter_class_compliance(bank) filters.verify_filter_class(bank), que devuelve el mismo FilterComplianceResult

verify_intensity_class y verify_quasi_peak_dynamics son posteriores a la 3.3.0, y en la 4.0.0rc1 ya devolvían sus registros.

from phonometry.filters import OctaveFilterBank, verify_filter_class
verdict = verify_filter_class(OctaveFilterBank(48000, fraction=1, limits=[125, 4000]))
print(verdict.overall_class, len(verdict.bands))

verify_running_rms_decay es posterior a la 3.3.0, y en la 4.0.0rc1 devolvía un bool desnudo, que tiraba el intervalo impreso y el tiempo medido que había juzgado. Ahora devuelve un RunningRMSDecayVerification que conserva los dos: el veredicto es .passes, junto a .measured_time_s, .printed_time_s, .tolerance_s y el intervalo como .lower_time_s y .upper_time_s. El objeto se niega a leerse como valor de verdad, así que un if verify_running_rms_decay(...): escrito contra la versión candidata levanta TypeError en vez de dar por buenos todos los vibrómetros.

Un veredicto dice passes, se niega a ser un valor de verdad y sale de un verbo

Sección titulada «Un veredicto dice passes, se niega a ser un valor de verdad y sale de un verbo»

Un juicio se nombra por lo que juzga: verify_ un instrumento, assess_ una situación medida, check_ la disposición que pide un método. Cada uno devuelve un registro que conserva sus razones, y el apto o no apto se escribe passes en todos ellos. Un registro que devuelve una función de juicio, y todo registro con un passes, se niega a leerse como valor de verdad: if verdict: lanza TypeError y el mensaje dice qué leer. En la 3.3.0 y la 4.0.0rc1 estos registros eran siempre verdaderos, así que un if escrito contra ellos daba por buenos todos los fallos: lee .passes en QuasiPeakDynamicsResult, AircraftSystemComplianceResult, WeightingVerification, PhaseVerification, SignalBurstVerification, DBHRCheck, DBHRAssessment, ActivityAssessment y PeriodAssessment; .overall_class en FilterComplianceResult, WeightingComplianceResult e IntensityInstrumentComplianceResult; .within_guideline en DamageAssessment, porque superar un valor guía de DIN 4150-3 no es un fallo; .qualified en PrecisionCriteria; .adjustment en TonalAssessmentResult; y .decisive_audibility o .audible en ToneAudibilityResult.

3.3.0 o 4.0.0rc1 4.0
.complies en DbHrCheck, DbHrAssessment (ahora DBHRCheck, DBHRAssessment), ActivityAssessment y PeriodAssessment .passes
vibration.is_significant_change(change, zone_b_upper) vibration.assess_operational_change(change, zone_b_upper).significant, junto al .threshold contra el que se lee. Un cambio significativo es un motivo para investigar, no un fallo, así que la bandera conserva su nombre
materials.limp_frame_applicable(k_c, criterion=...) materials.check_limp_frame(k_c, criterion=...).passes, junto a .ratio y .threshold. Una razón justo en el umbral ya no pasa: Allard y Atalla imprimen los dos criterios como desigualdades estrictas
fi.field_is_stationary(limit=...) en un FieldIndicators fi.check_field_stationarity().passes, y banda a banda su .stationary. El límite es el 0,6 de la tabla B.3, que se lee en .limit, y ya no es un argumento
room.perceptibly_different(symbol, first, second) room.assess_perceptible_difference(symbol, first, second).different; los dos valores tienen ahora que tener la misma forma
materials.check_base_plate_scattering(s) == () materials.check_base_plate_scattering(s).passes, con las bandas que superan el límite en .exceeded_frequencies y, junto a ellas, .margins, .exceeds y .limits por banda. Un coeficiente que no es finito lanza ValueError, donde antes pasaba
corrected, limited = building.background_corrected_level(lp, lb) result = building.background_corrected_level(lp, lb), y luego result.corrected_levels y result.limited
k1, held = emission.background_noise_correction_at_workstation(lp, lb) result = emission.background_noise_correction_at_workstation(lp, lb), y luego result.correction y result.upper_bound

Los nombres de primer nivel de la 3.3.0 que esto renombra (rigid_mass_calibration_check, satisfies_lower_requirement, satisfies_upper_requirement, strong_coupling_satisfied y tonal_seeking_survey) están en la tabla de los nombres que ya no están, al final de esta página.

from phonometry import building, materials
conformity = building.assess_requirement_conformity(52.0, 1.5, 50.0, bound="minimum")
print(conformity.passes, conformity.margin_db)
# True 0.5
check = materials.check_base_plate_scattering([0.02] * len(materials.BASE_PLATE_BANDS_HZ))
print(check.passes, check.exceeded_frequencies.size)
# True 0
try:
bool(check)
except TypeError as error:
print(type(error).__name__)
# TypeError

El banco de filtros devuelve un resultado, no una tupla

Sección titulada «El banco de filtros devuelve un resultado, no una tupla»

octave_filter() y OctaveFilterBank.filter() devolvían dos elementos normalmente y tres cuando sigbands=True pedía las señales por banda. La longitud de la respuesta dependía de una palabra clave, que es la razón por la que ese par necesitaba doce declaraciones @overload para poder tiparse, y por la que _, _, bands = bank.filter(...) era una línea en la que había que contar comas.

Ahora devuelven un OctaveFilterResult con campos con nombre. Las demás respuestas del banco que eran tuplas también son registros: el espectrograma es un OctaveSpectrogramResult, y el conjunto de bandas sobre el que se diseña el banco se lee de atributos con el nombre completo.

3.3.0 4.0
spl, freq = octave_filter(x, fs) r = octave_filter(x, fs), y luego r.levels y r.frequencies
spl, _ = octave_filter(x, fs) octave_filter(x, fs).levels
_, freq = octave_filter(x, fs) octave_filter(x, fs).frequencies
_, _, bands = bank.filter(x, sigbands=True) bank.filter(x, sigbands=True).require_bands()
levels, freq, times = bank.spectrogram(x) r = bank.spectrogram(x), y luego r.levels, r.frequencies y r.times (un OctaveSpectrogramResult, que se dibuja con r.plot())
bank.freq, bank.freq_d, bank.freq_u, bank.nominal_freq, bank.num_bands bank.frequencies, bank.lower_edges, bank.upper_edges, bank.labels, bank.n_bands, de solo lectura: los arrays rechazan la escritura y labels es una tupla
import numpy as np
from phonometry import filters
result = filters.octave_filter(np.zeros(8000) + 1e-6, 8000, fraction=3)
print(len(result.frequencies), result.bands)
# 25 None

bands es None salvo que la llamada haya pedido sigbands=True, y levels es None en una llamada hecha con calculate_level=False. El código que necesita cualquiera de los dos puede decirlo con require_bands() o require_levels(), que devuelven el valor o fallan nombrando el argumento que faltaba, en vez de entregar un None que revienta unas líneas más adelante.

El resultado también se dibuja solo, así que el espectro de bandas es una llamada:

ax = result.plot()

Otras respuestas que eran tuplas son registros

Sección titulada «Otras respuestas que eran tuplas son registros»

Todas las demás respuestas que volvían como una tupla de magnitudes distintas, que había que desempaquetar por posición, son ahora registros con campos con nombre, y ninguna se desempaqueta: una línea que aún lo haga lanza TypeError: cannot unpack non-iterable ... en vez de entregar la columna equivocada. Solo queda una tupla donde sus elementos son semejantes, como los dos extremos de un intervalo, el inferior primero.

3.3.0 o 4.0.0rc1 4.0
freq, lower, upper, labels = filters.nominal_frequencies(3) b = filters.nominal_frequencies(3), y luego b.frequencies, b.lower_edges, b.upper_edges y b.labels (un FractionalOctaveBands)
epnl, pnltm, kf, kl = aircraft.epnl_from_pnlt(pnlt) r = aircraft.epnl_from_pnlt(pnlt), y luego r.epnl, r.pnltm, r.band_limits (el par (kF, kL)), r.bandsharing_adjustment y r.duration_correction (un EPNLIntegration)
freqs, delta_l = building.improvement_octave_bands(dl, f) s = building.improvement_octave_bands(dl, frequencies=f), y luego s.frequencies y s.values (un OctaveBandSpectrum, cuyo quantity dice qué son los valores)
freqs, values = result.octave_bands() en un building.FloorCoveringImprovementResult result.octave_bands().frequencies y .values, el mismo OctaveBandSpectrum
l_in, s_m = building.combine_subareas(l_in, areas) r = building.subarea_intensity_level(l_in, areas), y luego r.levels y r.measurement_area (un SubareaIntensityLevel)
freqs, u = band_uncertainty.to_arrays() en un building.BandUncertainty band_uncertainty.frequencies y band_uncertainty.uncertainties, los campos de los que se leía
bx, bz, bxz = building.corrugated_plate_stiffness(...) b = building.corrugated_plate_stiffness(...), y luego b.b_x_n_m, b.b_z_n_m y b.b_xz_n_m (un CorrugatedPlateStiffness)
f, lower, upper = building.heavy_impact_source_limits(source) lim = building.heavy_impact_source_limits(source), y luego lim.frequencies, lim.lower y lim.upper (un HeavyImpactSourceLimits)
width, k = building.wall_tie_stiffness(tie), building.WALL_TIE_STIFFNESS[tie][1] t = building.wall_tie_stiffness(tie), y luego t.cavity_width_m y t.stiffness (un WallTieStiffness, que es también lo que guarda cada fila de WALL_TIE_STIFFNESS)
result.ratings en un building.LiningImprovementResult result.delta_rw, result.delta_ra y result.delta_ratr, los campos de los que se leía la tupla
f, gamma2 = electroacoustics.coherence(x, y, fs) c = electroacoustics.coherence(x, y, fs), y luego c.frequencies y c.coherence (un CoherenceResult, con .plot())
f, levels = emission.octave_band_levels(levels, f) o = emission.octave_band_levels(levels, frequencies=f), y luego o.frequencies y o.levels (un OctaveBandLevels, con .plot())
f, class_1, class_2 = emission.residual_index_limits(device) lim = emission.residual_index_limits(device), y luego lim.frequencies, lim.class_1 y lim.class_2 (un ResidualIndexLimits)
wavelengths, levels = environment.wheel_roughness(brake), y lo mismo con rail_roughness, contact_filter e impact_roughness_single w = environment.wheel_roughness(brake), y luego w.wavelengths_mm y w.levels (un WavelengthSpectrum, con .plot())
source_a, source_b = environment.traction_sound_power(vehicle), y lo mismo con aerodynamic_sound_power p = environment.traction_sound_power(vehicle), y luego p.source_a y p.source_b (un RailSourceSpectra)
RollingStock(wheel_roughness=(wavelengths, levels), traction=(a, b), ...), RailwayTrack(rail_roughness=(wavelengths, levels), ...) los mismos campos con un WavelengthSpectrum(wavelengths_mm=..., levels=...) o un RailSourceSpectra(source_a=..., source_b=...); un par suelto lanza TypeError con el nombre del campo
f, lower, upper = filters.weighting_class_limits(1) lim = filters.weighting_class_limits(1), y luego lim.frequencies, lim.lower y lim.upper (un WeightingClassLimits)
rho, kappa = materials.slit_effective_properties(f, ...), y lo mismo con rectangular_duct_properties p = materials.slit_effective_properties(f, ...), y luego p.effective_density y p.bulk_modulus (un EffectiveFluidProperties)
fc, alpha = materials.one_third_octave_absorption(alpha, f) b = materials.one_third_octave_absorption(alpha, frequencies=f), y luego b.frequencies y b.absorption (un OneThirdOctaveAbsorption, con .plot())
a, b, c, d = materials.wave_decomposition(...), p0, pd, u0, ud = materials.face_quantities(...) w = materials.wave_decomposition(...) con w.a a w.d (un WaveAmplitudes), q = materials.face_quantities(...) con q.p0, q.pd, q.u0 y q.ud (un FaceQuantities)
k, U = result.expanded(0.95) en un metrology.UncertaintyResult e = result.expanded(0.95), y luego e.coverage_factor y e.expanded_uncertainty (un ExpandedUncertainty)
f, spl = psychoacoustics.equal_loudness_contour(40.0), f, tf = psychoacoustics.hearing_threshold() c = psychoacoustics.equal_loudness_contour(40.0), y luego c.frequencies, c.levels y c.phon, que es None en el umbral (un LoudnessContour, con .plot())
f, v = vibration.foundation_guideline_curve(building_class) g = vibration.foundation_guideline_curve(building_class), y luego g.frequencies y g.velocities_mm_s (un GuidelineCurve)
chi, psi = vibration.junction_wave_parameters(...) w = vibration.junction_wave_parameters(...), y luego w.chi y w.psi (un JunctionWaveParameters)
time, level = room.decay_curve(ir, fs), que aún se desempaquetaba curve = room.decay_curve(ir, fs), y luego curve.times y curve.levels (un DecayCurve, que ya no se desempaqueta)
times, levels = environment.sound_pressure_level_history(x, fs) h = environment.sound_pressure_level_history(x, fs), y luego h.times y h.levels (un LevelHistory, que ya no se desempaqueta)
import numpy as np
from phonometry import aircraft, filters
bands = filters.nominal_frequencies(1, [125, 1000])
print(bands.labels)
# ('125', '250', '500', '1k')
epnl = aircraft.epnl_from_pnlt(np.array([90.0, 95.0, 90.0]), 0.5)
print(epnl.band_limits, round(epnl.duration_correction, 2))
# (0, 2) -10.88

El espectro en octavas se dibuja solo con .plot(), rotulado con su magnitud.

Los límites de tolerancia van primero el inferior, y con signo

Sección titulada «Los límites de tolerancia van primero el inferior, y con signo»

vibration.weighting_tolerance_percent devolvía la banda de la Tabla 5 de ISO 8041-1 como (upper, lower), y las tres constantes CENTRAL_TOLERANCE_PERCENT, SKIRT_TOLERANCE_PERCENT y TAIL_TOLERANCE_PERCENT guardaban (upper %, lower %, fase °). Todos los demás pares de límites de la biblioteca son (lower, upper), así que estos también lo son ahora. El límite inferior sigue siendo negativo, como lo imprime la tabla, y -100.0 sigue queriendo decir que la norma no fija límite inferior.

Este cambio no renombra nada ni lanza nada: upper, lower = ... sigue desempaquetando dos arrays, e intercambiados. Revisa cada desempaquetado de los cuatro:

4.0.0rc1 4.0
upper, lower = vibration.weighting_tolerance_percent(name, f) lower, upper = vibration.weighting_tolerance_percent(name, f)
vibration.CENTRAL_TOLERANCE_PERCENT == (12.0, -11.0, 6.0) (-11.0, 12.0, 6.0)
vibration.SKIRT_TOLERANCE_PERCENT == (26.0, -21.0, 12.0) (-21.0, 26.0, 12.0)
vibration.TAIL_TOLERANCE_PERCENT == (26.0, -100.0, inf) (-100.0, 26.0, inf)
from phonometry import vibration
lower, upper = vibration.weighting_tolerance_percent("Wk", [16.0])
print(lower, upper)
# [-11.] [12.]

Varios registros tenían campos que valían None por defecto, para que un resultado construido a mano con unos pocos de sus números se pudiera seguir construyendo. Cada lector tenía entonces que preguntar si el campo estaba: la ficha rechazaba un índice desnudo solo cuando se le pedía el informe, y un dibujo de la geometría avisaba de que el resultado «no conserva su geometría». Ahora los campos son obligatorios, y un registro construido sin uno de ellos, o con None en uno (también mediante dataclasses.replace), lanza TypeError nombrándolo.

Registro Obligatorio ahora
building.AirborneInsulationResult l1, l2, t2, t0
building.ImpactInsulationResult li, t2, t0
building.WeightedRatingResult, building.ImpactRatingResult frequencies, measured, shifted_reference
building.ExtendedWeightedRatingResult, building.ExtendedImpactRatingResult frequencies, measured
building.ApertureTransmissionResult depth, ahora el cuarto campo; y width_m para una rendija o radius para una abertura circular
building.FacadePredictionResult elements, ahora el sexto campo
emission.IntensityResult spacing_m, keyword-only
environment.BarrierInsertionLoss source_height_m, barrier_distance, barrier_height_m, receiver_distance, receiver_height_m, keyword-only
psychoacoustics.ZwickerLoudness field ("free" o "diffuse"), ahora el cuarto campo, antes de n5
room.OpenPlanResult positions_m, las distancias sobre las que se ajustaron los índices
materials.LayeredAbsorberResult layers, la secuencia de capas para la que se resolvió la predicción
materials.DiffuserPolarResponse well_width y n_repetitions, por nombre; depths sigue siendo opcional, porque una respuesta predicha a partir de un reflection explícito no la tiene
materials.MetadiffuserResult wells, depth_m y period_m, el panel para el que se resolvió la reflexión, por nombre
materials.SlitResonatorAbsorberResult resonators, slit_height_m, lattice_step_m y period_m, el panel para el que se resolvió la predicción, por nombre
materials.ImpedanceTubeResult spacing_m y x1, la separación de los micrófonos y la distancia de la muestra al micrófono más lejano, sin las que la reducción no puede hacerse, por nombre; diameter_m sigue siendo opcional, porque no hace falta darlo
materials.InSituAbsorptionResult source_height_m y microphone_height_m, el montaje con el que se midió la absorción, por nombre
vibration.JunctionTransmissionResult thickness1_m y thickness2_m, las placas de la unión, por nombre
noise_control.ReactiveSilencerResult plane_wave_limit, y exactamente uno de geometry (un dispositivo con nombre) y chain (una SilencerChain); resonances, geometry, plane_wave_limit y chain van por nombre

simulation.FDTDResult y simulation.ElasticFDTDResult toman dos campos más, detrás de los demás: snapshot_decimation, cada cuántas celdas guarda una instantánea en cada eje (1 para todas, como antes), y provenance, el simulation.RunProvenance de dónde se calculó la ejecución. Un resultado construido a mano pasa los dos, y dejar fuera uno lanza TypeError nombrándolo; los resultados que devuelven las funciones de simulación ya llevan los dos. Un RunProvenance construido a mano pasa todos sus campos, entre ellos phonometry_version, la versión de phonometry que calculó los pasos.

filters.WeightingFilter(..., high_accuracy=None) seleccionaba el valor por defecto. Ahora high_accuracy es un bool sin más, True por defecto, y None lanza TypeError en vez de leerse como falso, lo que elegiría el diseño simple.

building.CeilingAttenuationResult.rounded era un campo que pasaba quien llamaba. Ahora se lee de measured, redondeado al entero más próximo como pide la cláusula 5.2 de ASTM E413 (la cláusula no dice hacia dónde va la mitad, y la biblioteca la redondea hacia arriba), así que no puede contradecir los datos; déjalo fuera al construir el registro a mano.

Las formas de onda dentro de los resultados vuelven como el Signal del que salieron

Sección titulada «Las formas de onda dentro de los resultados vuelven como el Signal del que salieron»

Una transformación a la que se le entrega un Signal devuelve un Signal desde que se escribió el contrato, pero cinco objetos de resultado todavía guardaban su forma de onda como un array desnudo junto a un fs suelto. Ahora conservan el tipo con el que llegó la entrada:

Campo Es un Signal cuando la entrada lo era
envelope(...).signal a la frecuencia de muestreo de la entrada
time_synchronous_average(...).period_waveform a la frecuencia de muestreo de la entrada
resample_signal(...).signal a fs_new
align_impulse_responses(...).aligned, .reference cada uno si su propia entrada lo era
underwater.pile_strike_metrics(...).pressure a la frecuencia de muestreo de la entrada

Un array desnudo sigue devolviendo un array desnudo, así que el código que pasa arrays no lo nota. El código que pasa un Signal y hace aritmética con uno de estos campos pasa por np.asarray, como con cualquier Signal, y una entrada calibrada vuelve con calibration_factor=1.0, así que el campo alimenta a la función siguiente en pascales sin que el factor se aplique otra vez.

io.read_blocks es posterior a la 3.3.0, y en la 4.0.0rc1 entregaba arrays float64 desnudos. Ahora entrega un Signal por bloque, con la frecuencia de muestreo, la calibración, las etiquetas de canal y la procedencia que da io.read, y toma el mismo calibration_factor= y lee el mismo sidecar. Para un bucle escrito contra la versión candidata cambian dos cosas. Un bloque de un archivo calibrado llega a los filtros y a las funciones de nivel en pascales, así que un calibration_factor aplicado a mano encima cuenta dos veces. Y la aritmética sobre un bloque, o sobre lo que un filtro devuelve para él, pasa por np.asarray, como con cualquier Signal.

Toda tabla que la biblioteca publica a nivel de módulo es de solo lectura en la 4.0. En la 3.3.0 las tablas publicadas eran diccionarios corrientes y los arrays publicados admitían aritmética sobre el propio array, así que una línea como REFERENCE_CURVE[500] = 0.9 o BAND_IMPORTANCE *= 2 cambiaba el número para todo lo que se ejecutara después en el mismo proceso, sin que nada lo avisara. Los diccionarios son ahora types.MappingProxyType, también los que van anidados dentro de otra tabla, y los arrays tienen desactivada la bandera writeable. Leer no cambia; escribir lanza TypeError en una tabla y ValueError en un array.

El código que retocaba una tabla publicada tiene que copiarla antes:

from phonometry import room
from phonometry.materials.absorbers import REFERENCE_CURVE
curve = dict(REFERENCE_CURVE)
curve[4000] = 1.0
curves = room.NC_CURVE_LEVELS.copy()
curves[0, 0] = 0.0
print(REFERENCE_CURVE[4000], curve[4000], curves[0, 0], room.NC_CURVE_LEVELS[0, 0])
# 0.9 1.0 0.0 78.0

Una tabla que lleva tablas dentro necesita copiar cada nivel, como en {area: dict(rows) for area, rows in GUIDE_VALUES.items()}. La misma copia hace falta antes de serializar una tabla con pickle, copiarla en profundidad o escribirla como JSON, porque un mapeo de solo lectura no admite ninguna de las tres cosas.

Un resultado guarda una copia propia de los arrays que recibe

Sección titulada «Un resultado guarda una copia propia de los arrays que recibe»

En la 3.3.0 y en la 4.0.0rc1 un resultado guardaba el mismo array que se le pasaba siempre que ese array ya era del tipo que lee la función, float64 para niveles y frecuencias, porque en ese caso np.asarray devuelve su argumento sin tocarlo. Cambiar después el array de quien llamaba, levels[0] = 0.0 o frequencies *= 2, cambiaba un resultado ya calculado y quizá ya impreso. En la 4.0 todo array que una función o un método de la biblioteca guarda de los argumentos que recibe es una copia propia, de solo lectura como las tablas publicadas, y el array de quien llama queda como estaba. Lo mismo vale para los objetos que guardan arrays para entregarlos después: la rejilla de frecuencias de una noise_control.SilencerChain, los ejes y las trayectorias con los que se construye una aircraft.ANPDatabase y los mapas del medio de simulation.FDTD2D y simulation.ElasticFDTD2D, cuyos c, rho, c_p y c_s siguen siendo ahora aquellos con los que se calculó el paso de tiempo. Los mapas que las simulaciones derivan de ellos, FDTD2D.kappa y ElasticFDTD2D.mu y .lam, son también copias de solo lectura en NumPy: en la 4.0.0rc1 editar uno llegaba a parte del avance y no al paso de tiempo, y ahora lanza ValueError, así que otro medio es una simulación nueva construida con los mapas editados. Un Signal también guarda una copia propia de sus muestras, que sigue siendo escribible para procesarla en su sitio, como siempre lo fueron las muestras de un fichero leído con io.read. Un registro de resultado construido a mano, llamando directamente a su clase, hace la misma copia: todo registro público que puede guardar un array copia los arrays que recibe al construirse, lo construya quien lo construya, también dentro de una tupla, una lista o cualquier diccionario. Un registro guardado dentro de otro se guarda entero y responde de sus propios arrays, y un Signal no es una excepción: los siete resultados que devuelven una forma de onda como Signal (filters.OctaveFilterResult, signals.EnvelopeResult, signals.ResampledSignalResult, signals.AlignedImpulseResponseResult, signals.SynchronousAverageResult, environment.DirectSoundSubtraction y underwater.PileStrikeResult) guardan una propia cuando los construye la biblioteca, cuyas muestras siguen siendo escribibles como las de cualquier Signal, y guardan la de quien llama cuando se construyen a mano con ella. Todos los demás arrays que guarda un resultado rechazan las escrituras en su sitio, tanto los que calculó como los que recibió, cuando en la 3.3.0 la mayoría de los calculados las aceptaban. Escribir en uno lanza ahora ValueError, así que el código que retocaba uno en su sitio tiene que copiarlo antes:

import numpy as np
from phonometry import io, room
levels = np.array([60.0, 58.0, 55.0, 52.0, 50.0, 48.0, 45.0, 42.0, 40.0, 38.0])
nc = room.noise_criterion(levels)
levels[0] = 0.0
samples = np.zeros(4)
signal = io.Signal(samples, fs=48_000)
samples[0] = 1.0
measured = np.array([1.0, 0.5, 0.25, 0.125])
response = room.ImpulseResponseResult(ir=measured, fs=48_000, method="farina")
measured[0] = 0.0
edited = nc.levels.copy()
edited[0] = 62.0
print(nc.levels[0], nc.levels.flags.writeable, response.ir[0], response.ir.flags.writeable)
print(signal.data[0, 0], signal.data.flags.writeable)
# 60.0 False 1.0 False
# 0.0 True

La ventana con la que se calculó un resultado espectral se guarda igual. signals.power_spectral_density, signals.cross_spectral_density, signals.coherent_output_spectrum, signals.miso_coherence, signals.spectrogram, signals.zoom_fft, signals.envelope_spectrum y signals.window_metrics guardan la window que recibieron, y una ventana dada con sus parámetros guarda unos parámetros propios: los pesos de ("general_cosine", weights) dados como lista se guardan como una tupla de los mismos números, donde la 3.3.0 guardaba la lista de quien llamaba, así que result.window == ("general_cosine", (0.5, 0.5)); dados como array son una copia de solo lectura, como todo array que guarda un resultado. Un resultado construido a mano, o de nuevo con dataclasses.replace, guarda su ventana igual.

Una fila de catálogo dice lo que su fuente afirma de cada celda

Sección titulada «Una fila de catálogo dice lo que su fuente afirma de cada celda»

Los catálogos publicados de materiales son nuevos en la 4.0: ni la 3.3.0 ni la 4.0.0rc1 los tenían. Cambiaron de forma una vez de camino a la versión final, y el código escrito contra la rama principal entretanto necesita los cambios de abajo. Todas las filas de todos los catálogos comparten ahora una base, io.CatalogueRow (con io.BandedRow para una fila que imprime un valor por banda), y las mismas tres preguntas tienen la misma respuesta en cualquiera de ellas.

Antes 4.0
SolidMaterial.estimated, OrthotropicWood.estimated row.basis, que asigna "estimated" a cada campo con la nota al pie
SolidMaterial.is_estimate(field), OrthotropicWood.is_estimated(field) row.basis_of(field) == "estimated"
row.is_derived(field) en un valor que la página da en una unidad que la fila no guarda (los °F y psi de la Tabla 14.1 de Ver & Beranek, los sabines de la Tabla 7.1 de Long) field in row.converted; row.converted[field] es la cifra de la página y su unidad, como ("3e5", "psi")
row.is_derived(field) en un valor que la página da por referencia a otra de sus filas: una celda en blanco bajo un bloque (Tabla 8.7 de Ver & Beranek, Tabla 30 de ASHRAE) o una descripción que dice «Parecido al anterior» (capítulo 32 de Harris) field in row.carried; row.carried[field] nombra la fila
OrthotropicWood(...) y PlateauMaterial(...) con sus propios campos por posición todos los campos por nombre, como en cualquier otra fila
from phonometry._internal.catalogue import CatalogueRow from phonometry.io import CatalogueRow

is_derived responde ahora sólo por lo que calcula la biblioteca y podría volver a calcular con las celdas de la propia fila, como una velocidad de barra obtenida de un módulo y una densidad. Un valor que la página da en otra unidad sigue siendo el número de la página, y también lo es uno que da por referencia a otra de sus filas, así que ninguno de los dos es ya derivado. basis_of responde con la entrada del propio campo, si no con la de la fila, y si no con una cadena vacía, que quiere decir que la fuente no dice cómo se obtuvo el número; las cinco cosas que puede afirmar una fuente están en io.CATALOGUE_BASES.

from phonometry import solids
board = solids.PUBLISHED_SOLIDS["hopkins-2007-table-a2/plasterboard_natural_gypsum"]
ear = solids.damping_named("EAR C-1002")[0]
print(board.basis_of("poisson_ratio"))
# estimated
print(ear.converted["youngs_modulus_max_pa"], ear.is_derived("youngs_modulus_max_pa"))
# ('3e5', 'psi') False

Las capas elásticas pasaron a ser filas de catálogo en el mismo cambio. Una ResilientLayer es una io.CatalogueRow como cualquier otra fila, con la clave y la atribución de las demás:

Antes 4.0
PUBLISHED_RESILIENT_LAYERS["mineral_wool_rock_60_30"], resilient_layer("mineral_wool_rock_60_30") "hopkins-2007-table-a3/mineral_wool_rock_60_30", la clave "<tabla>/<fila>" de todos los catálogos
layer.attributed_to, una cadena layer.attributed_to["row"], un mapeo como en todas las filas
ResilientLayer(...) con la rigidez, la densidad y el espesor obligatorios todas las magnitudes opcionales, y apparent_dynamic_stiffness_n_m3 junto a dynamic_stiffness_n_m3 para una fuente que sólo da la aparente
layer.natural_frequency(mass_per_area=...) layer.natural_frequency(mass_per_area_kg_m2=...); una capa que sólo guarda toma además airflow_resistivity_pa_s_m2= y gas_stiffness_n_m3=, y sin el primero lanza ValueError

La Tabla A3 de Hopkins imprime , la rigidez de la capa instalada tal como la define la lista de símbolos del propio libro, así que sus quince filas siguen guardando dynamic_stiffness_n_m3 y devuelven las frecuencias naturales que devolvían. Cuatro de ellas guardan una densidad que la página imprime una sola vez para su bloque y deja en blanco en su propia línea, y layer.carried["density_kg_m3"] nombra ahora la fila que la imprime; la densidad es la misma.

from phonometry import materials
rebond = materials.resilient_layer("hopkins-2007-table-a3/rebond_foam_64_20")
print(rebond.attributed_to["row"], round(rebond.natural_frequency(mass_per_area_kg_m2=120.0), 1))
# Hopkins and Hall (2006) 43.6

Una fila de catálogo se comprueba al construirse

Sección titulada «Una fila de catálogo se comprueba al construirse»

Toda fila de catálogo se comprueba en su constructor, la construya la biblioteca a partir de una tabla empaquetada o quien llama a mano, y una celda que nada de lo que viene después podría leer lanza io.CatalogueError, nombrando la fila y el campo. El código escrito entretanto contra la rama principal que contara con que se aceptara algo de lo siguiente tiene que cambiar:

Antes se aceptaba 4.0
NaN, un infinito, True o un texto como "0,97" en un campo numérico CatalogueError; una celda que la página deja vacía es None
una fracción en un campo entero (year), 1 en un campo booleano (has_section_drawing), un número en un campo de texto CatalogueError
un name o un source vacíos, o un matiz cuyo texto está vacío, como misprinted={"porosity": ""} CatalogueError; why_missing respondía "" para esa celda, lo que escondía el matiz
un matiz con la clave de un campo que la clase no tiene, como en ranges={"no_such_field": ...}, o un matiz sobre un número (ranges, approximate, unquantified, …) con la clave de un campo de texto CatalogueError, que nombra el matiz y la clave
bounded_above o bounded_below sobre un campo sin intervalo; un intervalo, o uno de los intervalos de las lecturas de reported, con un extremo que no es finito o con el extremo bajo por encima del alto; una lista de reported sin nada dentro; una uncertainty negativa CatalogueError
un valor junto a misprinted, unquantified, not_derivable o reported en el mismo campo; una entrada de converted o carried en un campo que no guarda nada CatalogueError: los cuatro primeros dicen que no hay valor que servir, y los dos últimos no tienen nada que describir
un valor negativo en un campo cuyo nombre acaba en _kg_m3, _kg_m2, _kg, _kg_mol, _m_s, _pa, _pa_s_m2, _pa_s_m, _n_m3, _mm, _um, _m, _m2, _m_hz o _per_cm (una densidad, una masa por unidad de superficie, una masa, una masa molar, una velocidad, una presión o un módulo, una resistividad al flujo, una resistencia al flujo específica, una rigidez por unidad de superficie, una longitud, un área, un producto espesor por frecuencia, una cuenta por centímetro); una porosidad fuera de 0 a 1; shot_content_percent, binder_content_percent o adhered_area_percent fuera de 0 a 100 CatalogueError; una temperatura en grados Celsius, una tasa de decaimiento por metro y un nivel en decibelios siguen pudiendo ser negativos
approximate=[...] guardado como la lista que se le dio, un mapeo guardado como el diccionario un frozenset, y todo mapeo congelado hasta el fondo, con sus pares en tuplas
un campo de una subclase anotado con un tipo para el que el contrato no tiene comprobación, un float o un int a secas incluidos TypeError la primera vez que se construye la clase; un campo es float | None (Optional[float] es lo mismo), int | None, bool, str, frozenset[str] o un Mapping[str, ...] de ellos, porque cualquier celda de una fila puede faltar
PorousMaterial.frame_constants() sobre una fila sin structural_loss_factor, leída como un esqueleto que no disipa nada ValueError, que dice qué tenía la página en esa celda
GroundSurface.porosity con valores de 26,9 a 58,1 en seis filas de la Tabla 6.7 de Cox y D’Antonio, que la página imprime en tanto por ciento en una columna de fracciones que no dice su unidad None, con misprinted["porosity"] citando la cifra que imprime la página; why_missing("porosity") y printed("porosity") lo dicen

Todas las demás filas empaquetadas cumplían ya el contrato, así que esas seis porosidades son las únicas celdas publicadas que cambian, y todas las filas porosas publicadas con los dos módulos imprimen su factor de pérdidas.

from phonometry import io, materials
try:
materials.PorousMaterial(name="Panel core", source="a datasheet", porosity=97.0)
except io.CatalogueError as error:
print(error)
# 'Panel core': porosity is 97.0, and a porosity is a fraction from 0 to 1
carpet = materials.Carpet(
name="Loop pile", source="a datasheet", pile_height_mm=6.0, approximate=["pile_height_mm"]
)
print(carpet.approximate)
# frozenset({'pile_height_mm'})

La clase de un banco de filtros lee todos los requisitos de IEC 61260-1

Sección titulada «La clase de un banco de filtros lee todos los requisitos de IEC 61260-1»

verify_filter_class calificaba solo la máscara de la Tabla 1. Para la edición de 2014 califica ahora también la desviación del ancho de banda efectivo del 5.12 y la suma de las señales de salida del 5.16, calculadas como las calcula IEC 61260-2:2016, y la class de una banda y la overall_class del banco son la clase más estricta que se cumple en los tres. Para la edición de 1995 califica la respuesta integrada del filtro del 4.5.3 y la suma de las señales de salida del 4.9 junto a la Tabla 1, como las ensaya el capítulo 5 de esa edición. En las dos ediciones cada banda se califica a la frecuencia de entrada del banco hasta su mitad, así que una banda diezmada se califica sobre las imágenes que su diezmado pliega sobre ella, y el diezmador del banco las deja a más de 125 dB por debajo.

Antes 4.0
cada banda de un banco diezmado se diezmaba hasta que su frecuencia de Nyquist de proceso era 1,25 veces su borde superior de banda se diezma sólo hasta dejarla en dieciséis veces ese borde, así que la transformación bilineal ya no deforma la banda: el nivel de una banda se mueve hasta 0,07 dB con ruido blanco, sobre todo en las bandas más bajas, y el banco de octavas, que sumaría sus salidas hasta +0,94 dB y leería clase 2 en el 5.16, es clase 1 en todos los requisitos
la class de una banda leída de margin_class{c}_db class sobre todos los requisitos; margin_class{c}_db sigue siendo el margen de la Tabla 1, junto a bandwidth_margin_class{c}_db y summation_margin_class{c}_db, que vale None en las dos bandas de los extremos
un solo requisito por el que preguntar requirements, requirement_class(name) y binding_margin(name, cls) leen cada uno por separado, y plot(requirement="summation") lo dibuja
un veredicto con edition="1995" solo sobre la Tabla 1 la Tabla 1, "effective_bandwidth" (la respuesta integrada del filtro del 4.5.3) y "summation" (4.9, recorrida de la frecuencia central más baja a la más alta, así que las bandas de los extremos también la llevan), las dos con la S que el 5.3.3 sube en pasos de 12 hasta que la respuesta integrada se estabiliza, que el points_per_bandwidth del resultado indica (36 para el banco de octavas por defecto)
una banda diezmada calificada hasta la frecuencia de Nyquist de su frecuencia diezmada, con checked_to_omega parado ahí calificada a la frecuencia de entrada hasta su mitad, imágenes incluidas; checked_to_omega es la mitad de la frecuencia de entrada entre la frecuencia central, y range_limited marca una máscara de la Tabla 1 que sigue más allá
el filtro antialiasing que scipy.signal.resample_poly diseña por defecto, que dejaba las imágenes del banco de octavas a 8, 16 y 32 kHz 68,9 dB por debajo, sin llegar a los 70 dB de la clase 1 un filtro de la misma longitud dimensionado para una banda atenuada de 120 dB, con sus imágenes al menos 125,4 dB por debajo; el nivel de una banda se mueve menos de 0,01 dB

Los bancos de octavas y de tercios de octava siguen siendo clase 1.

from phonometry import filters
octave = filters.verify_filter_class(
filters.OctaveFilterBank(48000, fraction=1, limits=[125, 4000]))
print(octave.overall_class, octave.requirement_class("relative_attenuation"))
# 1 1

Un veredicto lee de la norma el límite que esta imprime

Sección titulada «Un veredicto lee de la norma el límite que esta imprime»

Un veredicto llevaba antes como campo del constructor el límite con el que se le juzgaba. En 3.3.0 lo hacían tres: ToneAssessment.criterion_db, ExposureAssessment.action_value y limit_value, y RigidMassCalibrationResult.tolerance. Otros seis, posteriores a 3.3.0, lo hacían en 4.0.0rc1, y el resto de la tabla llegó después de 4.0.0rc1. Cualquier código que construyera uno a mano, o que lo reescribiera con dataclasses.replace, podía juzgar una medición contra cualquier número y seguir poniendo el nombre de la norma encima del resultado. En 4.0 todo límite que imprime una norma es una propiedad de solo lectura, leída de los campos que la seleccionan: las bandas, la condición, la fuente, la clase, la sala. Un veredicto que se guardaba junto a su límite se lee también de los campos medidos, o se contrasta con ellos al construir el resultado, de modo que no puede contradecir el límite. Las funciones que devuelven estos veredictos reciben los mismos argumentos y dan las mismas respuestas, y cada nombre de la tabla, con su grafía de la 4.0, sigue leyendo el mismo valor; solo cambia el código que construye un veredicto directamente o que sustituye uno de estos campos. La última columna indica en qué versión apareció cada veredicto.

Veredicto Ya no son campos del constructor Campos que conserva o gana Desde
building.PositionSpreadCheck limit_db, stage, spread_db, action, next_positions, corner_standard_deviation_db levels, del que se leen todos después de 4.0.0rc1
building.HeavyImpactSourceCheck frequencies, nominal, tolerance_db, deviation, within_tolerance, passes source, measured 4.0.0rc1
noise_control.BandFlatnessCheck limit_db, within_limit, passes octave_frequencies, spread_db después de 4.0.0rc1
noise_control.SourcePositionCheck n_required_positions, passes, exceeds_max n_positions_used, max_octave_spread_db después de 4.0.0rc1
noise_control.EnclosureTestEnvironmentCheck environmental_correction_limit_db, background_margin_limit_db, required_area_ratio, passes base_standard, actual_area_ratio, mean_absorption_coefficient después de 4.0.0rc1
environment.ReflectionGridCheck nominal_m, deviations_m, within check, path_differences_m después de 4.0.0rc1
emission.HardWalledRoomCheck limit_db, min_volume_m3, box_dimension_limit_m, min_microphone_distance_m las bandas, la sala y la caja de referencia después de 4.0.0rc1
emission.ReferenceSoundSourceVerdict todos los *_limit_db, adjacent_step_db, core_range_db, extended_range_db, frequency_range_met, not_judged las bandas, los niveles y las cifras medidas después de 4.0.0rc1
emission.ReferenceSourceDriftResult, emission.SpecialRoomSuitabilityCheck limit_db las bandas después de 4.0.0rc1
emission.SpecialRoomReverberationCheck lower_limit, upper_limit las bandas después de 4.0.0rc1
emission.IntensityInstrumentComplianceResult limit_class1, limit_class2, spacing_offset_db device, spacing_m; las filas por banda se leen de ellos, véase la sección siguiente 4.0.0rc1
emission.InverseSquareLawResult, emission.SourceDirectionalityResult tolerance_db lo selecciona room; los radios cualificados deben ser los que alcanzan los niveles después de 4.0.0rc1
hearing.AmbientNoiseCheck limits_db, table_bands_hz gana earphone_attenuation y allowed_threshold_shift_db después de 4.0.0rc1
hearing.FixtureIsolationVerification min_isolation las bandas después de 4.0.0rc1
hearing.REATSoundFieldCheck allowable_variation_db gana free_field_rejection después de 4.0.0rc1
hearing.DiffuseSoundFieldCheck allowable_variation_db gana front_to_random_index después de 4.0.0rc1
hearing.FreeSoundFieldCheck axis_offset_m, inverse_distance_difference los seleccionan field y loudspeaker_distance_m después de 4.0.0rc1
electroacoustics.ProgramSignalCheck offset_db, relative_levels, lower_tolerance_db, upper_tolerance_db frequencies, band_levels después de 4.0.0rc1
electroacoustics.NeckLoopVerification limits lo selecciona neck_loop_type después de 4.0.0rc1
psychoacoustics.ToneAssessment prominence_limit_db, prominent gana method, "tone_to_noise_ratio" o "prominence_ratio" 3.3.0
underwater.WeightedExposureResult criteria gana impulsive 4.0.0rc1
vibration.ExposureAssessment action_value, limit_value, exceeds_action, exceeds_limit, zone value, kind, metric 3.3.0
vibration.PhaseVerification, vibration.WeightingVerification tolerance_deg (fase), within_tolerance la ponderación y las frecuencias 4.0.0rc1
vibration.RunningRMSDecayVerification printed_time_s, tolerance_s method, integration_time, measured_time_s después de 4.0.0rc1
vibration.SignalBurstVerification printed, deviation_percent, tolerance_percent, within_tolerance la fila de la tabla, las columnas y measured 4.0.0rc1
vibration.VibrationMeterVerification lower_percent, upper_percent, within_tolerance gana measured_response después de 4.0.0rc1
vibration.AssessmentVelocity guide_value_mm_s lo selecciona building_class después de 4.0.0rc1
vibration.MountingCheck passes, frequency_limit_hz, peak_acceleration_limit_m_s2, device gana peak_acceleration_m_s2 y upper_frequency_hz después de 4.0.0rc1
vibration.DamageAssessment guideline_mm_s gana massive_structure, solo por nombre 4.0.0rc1
vibration.RigidMassCalibrationResult expected, relative_deviation, within_tolerance, passes, relative_tolerance frequencies, measured, mass, quantity 3.3.0
vibration.LevelDifferenceCheck limit_db lo selecciona condition después de 4.0.0rc1
vibration.OutputMassCheck mass_limit_kg gana output_apparent_mass_kg, la fuerza de salida medida entre la aceleración de salida después de 4.0.0rc1

También cambian dos llamadas. rigid_mass_calibration_check, hoy verify_rigid_mass_calibration, ya no recibe tolerance: el apartado 7.5.2 de ISO 7626-2:2015 dice que el bloque «shall agree within ±5 %», así que una aceptación interna más estricta se lee de .relative_deviation. Y HeavyImpactSourceCheck y RigidMassCalibrationResult, cuyo passes era un campo almacenado, se niegan a leerse como valor de verdad igual que los demás veredictos: if check: lanza TypeError y el veredicto es .passes.

import dataclasses
from phonometry import vibration
check = vibration.check_blocked_output(frequencies=[100.0, 200.0], input_acceleration_level=[90.0, 95.0], output_acceleration_level=[60.0, 70.0])
print(check.limit_db, check.passes)
# 20.0 True
try:
dataclasses.replace(check, limit_db=10.0)
except TypeError as error:
print(type(error).__name__)
# TypeError
calibration = vibration.verify_rigid_mass_calibration([0.104, 0.093], frequencies=[50.0, 500.0], mass=10.0)
print(calibration.relative_tolerance, calibration.within_tolerance.tolist())
# 0.05 [True, False]

Los límites que una norma deja en manos del usuario siguen siendo campos: los límites de rugosidad y de tasa de decaimiento «por defecto» de ISO 3095, la tolerancia que ISO/DIS 16032 7.6 no imprime para «aproximadamente 30 s», el periodo de curado que fija la especificación del producto según ISO 10140-1 G.4, el desplazamiento de umbral que ISO 8253-1 deja aceptar al examinador, y los límites de especificación, de caso de ensayo y de fila de límites que se pasan a las comprobaciones de conformidad, de ISO 17534-1 y del RD 1367/2007. Los registros de requisitos de ISO 8297 y de IEC 60118-4, PlantRequirement y LoopRequirement, también conservan como campo el límite de cada fila: un mismo tipo de registro reúne requisitos cuyos límites mezclan cifras impresas con la geometría de la planta, la intensidad de campo especificada o el ruido medido con el bucle apagado.

Un veredicto se lee de los valores que guarda

Sección titulada «Un veredicto se lee de los valores que guarda»

La sección anterior sacó de los constructores los límites impresos. Las banderas del veredicto se quedaron dentro: passes, qualified, todos los *_met y *_ok, los avisos y la clase de cada banda de un veredicto de filtro, de ponderación o de instrumento de intensidad. La función que construía el resultado las calculaba y las guardaba junto a las lecturas de las que salían, así que un resultado construido a mano, o reescrito con dataclasses.replace, podía guardar lecturas que no cumplen y una bandera que dice que sí. En 4.0 todas son propiedades de solo lectura, leídas de los valores que guarda el resultado y del límite que imprime la norma. El resultado conserva aquello de lo que se lee su veredicto: las lecturas, los márgenes, las posiciones, las cifras medidas. Una cifra que solo alimentaba el veredicto, como el nivel redondeado de un periodo del RD 1367/2007 o la fracción de gotas de lluvia dentro de su tolerancia, también es una propiedad. Las funciones que devuelven estos resultados reciben los mismos argumentos y dan los mismos veredictos, y cada nombre de la tabla sigue leyendo el mismo valor; solo cambia el código que construye uno de estos resultados directamente o que sustituye uno de los campos de la lista. «Solo por nombre» marca un campo que solo se pasa por nombre.

Resultado Ya no son campos del constructor Se lee de Desde
building.JointTestElementCheck length_ok, width_ok, passes joint_length_m, joint_width_mm, window_or_door_gap después de 4.0.0rc1
building.GapWidthCheck gap_width_mm, spread_mm, enough_positions, uniform, passes readings_mm después de 4.0.0rc1
building.JointGapSeriesCheck nominal_measured, min_measured, working_range_measured, passes gap_widths_mm, nominal_gap_mm, min_gap_mm después de 4.0.0rc1
building.LiningCuringCheck cured, lag_within_third, passes curing_time_days, time_lag_days, required_curing_days después de 4.0.0rc1
building.RainGeneratorVerification rate_deviation_mm_h, rate_ok, drop_share, drops_ok, velocity_share, velocities_ok, passes rain_type, rainfall_rate_mm_h, drop_diameters_mm, fall_velocities_m_s después de 4.0.0rc1
building.ServiceEquipmentPositionCheck separation_m, surface_distance_m, source_distance_m, heights_m, corner_height_m, corner_wall_distances_m y los seis *_ok la sala, la esquina y las posiciones después de 4.0.0rc1
building.DBHRCheck reported, margin, passes requirement, value 4.0.0rc1
building.LowFrequencyIntensityResult, building.LowFrequencyElementResult qualified surface_pressure_intensity_indicator, frente al límite de 6.4.2 que selecciona absorbing_specimen_surface 4.0.0rc1
electroacoustics.BackgroundNoiseAssessment reference_signal_to_noise_ratio_db, category, report_required noise_levels, noise_is_tonal después de 4.0.0rc1
electroacoustics.FeedbackStabilityResult is_stable loop_gain, stability_margin 4.0.0rc1
emission.FreeFieldCheck room, frequencies, band_radius_m, max_qualified_radius_m, todos los *_met, full_frequency_range, conforming_range_hz, conforming_radius_m, not_judged los argumentos de check_free_field: gana source_directionality, reflecting_plane_absorption_coefficient, reflecting_plane_margin_m, paths_in_working_area, speed_of_sound después de 4.0.0rc1
emission.IntensityInstrumentComplianceResult bands, overall_class, range_limited frequencies, residual_index, device, spacing_m 4.0.0rc1
emission.ReferenceSourceCalibration sound_power_level, intensity_bands, intensity_agreement, room_qualified gana intensity_sound_power_level y room_qualification después de 4.0.0rc1
emission.HardWalledSoundPowerResult background_requirement_met, upper_bound gana background_margin_db, reference_background_margin_db después de 4.0.0rc1
emission.InSituSoundPowerResult background_requirement_met, upper_bound, grade, sigma_r0, sigma_tot, expanded_uncertainty gana background_margin_db, reference_background_margin_db, los menores de todas las posiciones, y excess_levels, directivity_range_db, los dos indicadores con los que la tabla 2 asigna el grado 4.0.0rc1
emission.SpecialRoomSoundPowerResult background_requirement_met, background_requirement_met_a gana background_margin_db, reference_background_margin_db, background_margin_a_db después de 4.0.0rc1
emission.EmissionPressureResult upper_bound gana background_margin_db, solo por nombre 4.0.0rc1
emission.PrecisionCriteria de criterion_1 a criterion_5, qualified gana las lecturas: indicators, scan_intensity_level_1, scan_intensity_level_2, frequencies, repeatability_limit_db, pressure_residual_index, field_nonuniformity_1, field_nonuniformity_2 3.3.0
emission.DiscretePointIntensityResult todo salvo los indicadores y el grado: partial_power, sound_power, sound_power_level, achieved_grade, los dos criterios, las cifras con ponderación A y el resto gana normal_intensity, segment_areas_m2, pressure_residual_index, fraction 4.0.0rc1
emission.TurbineTestEnvironmentCheck correction_ok, wind_ok, windscreen_advised environmental_correction, ratio, wind_speed_m_s después de 4.0.0rc1
environment.ImpulseOnset level_difference, prominence, qualifies level_start, level_end, onset_rate 3.3.0
environment.ImpulseProminenceResult per_impulse, qualifies, prominence, adjustment onset_rates, level_differences, assessment_period_minutes 3.3.0
environment.ResidualCorrectionResult reliable margin 3.3.0
environment.PeriodAssessment reported_level, reported_long_term, max_phase_level, phase_pass, daily_pass, long_term_pass phases, los dos niveles y limit; gana new_activity, solo por nombre 4.0.0rc1
environment.ModulationPeriod modulation_depths_db, fundamental_frequencies_hz, n_valid_blocks, rated, rating_db, mean_modulation_frequency_hz, mode_modulation_frequency_hz blocks después de 4.0.0rc1
environment.SoundRelevantTurbines relevant, total_level, relevant_level predicted_levels después de 4.0.0rc1
environment.WindShearProfile typical shear_exponent después de 4.0.0rc1
environment.WindTurbineTonalityResult is_audible tonal_audibility, has_identified_tone, que también es de solo lectura (sección siguiente) 3.3.0
filters.FilterComplianceResult bands, overall_class, range_limited gana band_margins, las filas sin su clase 3.3.0
filters.WeightingComplianceResult bands, overall_class, range_limited gana band_margins, las filas sin su clase 4.0.0rc1
hearing.AscendingThresholdResult threshold_level, determined, series_exhausted ascent_levels, shortened después de 4.0.0rc1
hearing.TaskContribution spread_advisory n_samples, sample_range_db 3.3.0
hearing.ExposureResult sampling_advisory gana sample_range_db, n_workers, sample_duration_hours, solo por nombre 3.3.0
hearing.AttenuationDifferenceResult difference, significance_limit_db, significant las dos medias y sus incertidumbres expandidas después de 4.0.0rc1
materials.CeilingSpecimenCheck area_error_m2, deflection_ok, substructure_ok, fixture_ok, supports_ok, humidity_ok, ce_marking_depth, passes gana las cifras medidas: deflection_mm, substructure_width_mm, substructure_height_mm, fixture_density_kg_m2, support_width_mm, support_height_mm, support_center_distance_m, lowest_relative_humidity_percent después de 4.0.0rc1
metrology.TrendTestResult trend_free, bounds statistic, frente a la región que dan values, method, alpha y median 3.3.0
metrology.StationarityTestResult stationary, bounds trend_statistic, frente a la región que dan segment_values, method y alpha 3.3.0
metrology.CouplerCheck ratio_recommended, approximation_valid, full_solution_advised, conditions_valid gana heat_conduction_method, temperature_c, static_pressure_pa, relative_humidity_percent, in_air, solo por nombre después de 4.0.0rc1
metrology.FreeFieldArrangementCheck distances_ok, support_ok, annex_a_range, attenuation_accuracy gana air_attenuation después de 4.0.0rc1
noise_control.CabinUncertainty ratio_satisfied, stateable, stated_band_range_hz, increased_uncertainty_band_range_hz, excess_standard_deviation_db method, volume_ratio después de 4.0.0rc1
room.RoomAcousticsResult edt_valid, t20_valid, t30_valid dynamic_range y los tiempos de caída 3.3.0
room.BackgroundMarginCheck needs_correction, unusable, passes margins_db después de 4.0.0rc1
room.PredictionDetailCheck passes, room_ok, fittings_ok, sources_ok gana room_detail, fitting_detail, source_detail después de 4.0.0rc1
underwater.WeightedExposureResult exceeds_injury, exceeds_tts sel_margin, peak_margin, tts_margin, tts_peak_margin 4.0.0rc1
vibration.PeopleAssessment passes, criterion, within_uncertainty kb_fmax, kb_ftr, guide, source; gana rare_short_events, solo por nombre después de 4.0.0rc1
vibration.RailwayChange passes, kb_fmax_met, kb_ftr_met, kb_fmax_increase_percent, kb_ftr_increase_percent gana kb_fmax_before, kb_fmax_after, kb_ftr_before, kb_ftr_after después de 4.0.0rc1
vibration.TransferStiffnessResult valid gana transmissibility, el |T| del método indirecto 3.3.0
vibration.DrivingPointStiffnessResult adequate gana blocked_output_difference, unwanted_input_difference después de 4.0.0rc1
aircraft.AircraftSystemComplianceResult passes, checks gana directional, frequency_response, linearity, resolution, los argumentos de verify_aircraft_noise_system 4.0.0rc1
broadcast.QuasiPeakDynamicsResult passes, worst_margin_db, worst_deviation_db, stimuli gana readings_percent, las once lecturas en el orden de las tablas 2 y 3 4.0.0rc1
building.FloorCoveringImprovementResult limited gana background_margin_db, el menor margen de todas las posiciones y de los dos forjados 3.1.0
building.VibrationReductionResult single_number, bracketed frequencies, k_ij; gana modal_overlap, fraction 3.1.0
building.ServiceEquipmentBackgroundResult difference, correction, corrected_levels, regime measured_levels, background_levels después de 4.0.0rc1
building.ServiceEquipmentResult standardizable frequencies, fraction después de 4.0.0rc1
emission.SoundPowerIntensityResult partial_power_level, sound_power, sound_power_level, negative_band, negative_partial_power_index, dynamic_capability_index, achieved_grade, a_weighting_omitted_bands, sound_power_level_a partial_power y los indicadores; gana pressure_residual_index, fraction, repeatability_limit_db 3.1.0
emission.PrecisionIntensityResult sound_power, sound_power_level, sound_power_level_normalized, not_applicable_band, sound_power_level_a partial_power; gana temperature_c, static_pressure_pa, solo por nombre 3.1.0
emission.InDuctSoundPowerResult information_only_band frequencies, flow_velocity 4.0.0rc1
emission.SourceLocationPlan spectral_character, a_weighted_spectral_character standard, standard_deviation_db, a_weighted_standard_deviation_db después de 4.0.0rc1
environment.ImpulsiveSoundResult prominence, adjustment, category, adjusted_laeq onsets, laeq 3.3.0
environment.ModulationBlock status prominence; gana excluded, solo por nombre después de 4.0.0rc1
environment.ReferenceTrackCheck conditions la rugosidad, las tasas de decaimiento y los límites; gana curve_radius_m, track_gradient_ratio, solo por nombre después de 4.0.0rc1

FilterComplianceResult y WeightingComplianceResult guardan sus filas por banda como band_margins: las filas que guardaba bands, sin la clave "class". Una fila que declara una clase se rechaza, y la propiedad bands añade a cada fila la clase que ganan sus márgenes, de modo que result.bands[i]["class"] se lee como antes. IntensityInstrumentComplianceResult ya no recibe filas por banda: guarda las frecuencias y el índice presión-intensidad residual medido, y lee de ellos, del dispositivo y de la separación de los micrófonos las filas, la clase y range_limited.

Las filas de las que se lee un veredicto son de solo lectura. band_margins y between_nominals se copian en diccionarios de solo lectura al construir el resultado, de modo que escribir en una lanza TypeError y escribir después en los diccionarios con los que se construyó no mueve la clase; para cambiar una fila, cópiela con dict(row), porque copy.deepcopy no puede copiar un diccionario de solo lectura. Las filas de AircraftSystemComplianceResult.checks, QuasiPeakDynamicsResult.stimuli y ReferenceTrackCheck.conditions se construyen, cada vez que se leen, a partir de lo que guarda el resultado y de las tablas de la norma.

import dataclasses
from phonometry import building, filters
gap = building.check_gap_width([5.0, 5.1, 5.2, 5.1])
print(gap.passes, round(gap.spread_mm, 1))
# True 0.2
try:
dataclasses.replace(gap, passes=False)
except TypeError as error:
print(type(error).__name__)
# TypeError
wider = dataclasses.replace(gap, readings_mm=(5.0, 5.1, 5.6, 5.1))
print(wider.uniform, wider.passes)
# False False
bank = filters.OctaveFilterBank(fs=48000, fraction=1, order=6, limits=[125, 4000])
result = filters.verify_filter_class(bank)
print(result.overall_class, result.bands[0]["class"], "class" in result.band_margins[0])
# 1 1 False

Una bandera sigue siendo un campo cuando no es un veredicto contra un límite y nada de lo que guarda el resultado la decide: una opción que fija quien llama, como small_room o noise_is_tonal; una rama que eligió quien llama con lo que pasó, como InverseSquareLawResult.origin_fitted; un hecho de una entrada que el resultado no guarda, como TimeWeightedEnvelope.calibrated; una propiedad del fichero leído; si un resolvedor iterativo convergió; y una columna de una fila de una tabla publicada. CriticalCouplingResult.converged conserva el desenlace de su resolución, que el resultado no puede repetir, pero ya no puede declarar la convergencia junto a una absorción que no supera 0,999, la tercera condición de la bandera. Un régimen que el resultado podría leer de sus propios valores es un veredicto, y la sección siguiente enumera los que se han movido. PlantRequirement y LoopRequirement no cambian: sus filas conservan cada límite como campo por la razón que da la sección anterior, y PlantRequirement.holds sigue junto a él. TrackCondition conserva su holds como fila del informe, pero ReferenceTrackCheck construye sus condiciones a partir de la vía que guarda, así que ningún veredicto lee una construida en otro sitio. También se quedan los checks de sí o no de SoundLevelMeterPeriodicRequirement: son lo que vio quien ensaya, una sobrecarga indicada o un indicador enclavado, no un límite juzgado.

Un resultado lee su régimen de los valores que guarda

Sección titulada «Un resultado lee su régimen de los valores que guarda»

Algunos resultados guardaban un régimen o una clasificación junto a los valores de los que se leía: el régimen de una válvula, si un martillo rebota, si el terreno apantalla un trayecto, si se encontró un tono, si un promediado síncrono tuvo que interpolar. La función comparaba valores que el resultado guarda, o podría guardar, con una constante o con un umbral que imprime su fuente, y guardaba la respuesta, así que un resultado construido a mano podía guardar la rigidez de un martillo en régimen subcrítico y decir que es sobrecrítico. En 4.0 cada una es una propiedad de solo lectura, leída de los valores que conserva el resultado, y un resultado que no conservaba lo que lee la prueba ahora lo conserva, con la unidad en el nombre. «Solo por nombre» marca un campo que solo se pasa por nombre.

Un valor justo en un límite cae donde lo pone la fuente. Hopkins imprime el caso sobrecrítico como K m ≥ 4 Zdp², así que el amortiguamiento crítico es sobrecrítico, e IEC TS 61400-11-2 pide un total «al menos 3 dB» por encima del fondo para la resta logarítmica, así que una diferencia de 3 dB la recibe. IEC 60534-8-4 no zanja su umbral de cavitación en un solo sentido: la prueba de 5.1 no deja el umbral mismo de ningún lado, la región de la Ecuación (9) y la Ecuación (19b) lo ponen con los puntos con cavitación, y 4.1, la Ecuación (18b) y 6.3 con los turbulentos. La biblioteca lo lee como turbulento, donde la Ecuación (9) devuelve cero y las dos ramas se encuentran sin escalón.

Las funciones reciben los mismos argumentos y devuelven los mismos números. Tiene que cambiar el código que construye uno de estos resultados directamente o que sustituye uno de los campos de los que se lee su régimen, y también el que lee fraction de vibration_reduction_index (véase debajo de la tabla).

Resultado Ya no es campo del constructor Se lee de Desde
building.TappingForceResult over_critical, K m ≥ 4 Zdp² (Hopkins, ecuación 3.95) contact_stiffness, impedance; gana mass, solo por nombre 4.0.0rc1
noise_control.HydrodynamicValveNoise regime, con cavitación cuando Δp supera x_Fzp1 (p1 - pv) (IEC 60534-8-4, 5.1) differential, corrected_ratio; gana inlet_pressure_pa, vapor_pressure_pa 4.0.0rc1
noise_control.AerodynamicValveNoise regime, los cinco intervalos de IEC 60534-8-3, 5.2 pressure_ratio, boundaries; gana specific_heat_ratio, pressure_recovery, efficiency_correction, solo por nombre 4.0.0rc1
aircraft.TerrainScreeningResult screened, terreno estrictamente por encima de la línea de visión source, receiver, distances_m, heights_m 3.3.0
hearing.AutomaticThresholdResult is_peak, retained (ISO 8253-1, 6.3.5 a)) reversal_levels después de 4.0.0rc1
hearing.SweepThresholdResult is_peak reversal_levels después de 4.0.0rc1
metrology.WaveMotionCorrection interpolated frequencies, speed_of_sound_ratio después de 4.0.0rc1
noise_control.CabinInsulationResult apparent (ISO 11957, 3.6) method después de 4.0.0rc1
noise_control.WeightedCabinInsulation apparent (ISO 11957, 3.9) method, que weighted_cabin_insulation recibe ahora como lo recibe cabin_insulation después de 4.0.0rc1
environment.WindTurbineTonalityResult has_identified_tone (IEC 61400-11, 9.5.2 a 9.5.4) levels, frequencies; gana candidate_frequency_hz, solo por nombre 3.3.0
building.LaboratoryJointInsulationResult regime (ISO 10140-1, J.1) r_s_prime, r_s_max; gana limit_at_max, solo por nombre después de 4.0.0rc1
environment.TurbineSoundLevels regimes (IEC TS 61400-11-2, 11.7) total_levels, background_levels después de 4.0.0rc1
underwater.WestonPropagationResult regime range_m, boundaries 4.0.0rc1
signals.SynchronousAverageResult interpolated, f_s T no es un número entero de muestras fs, period_s 4.0.0rc1

building.VibrationReductionResult.fraction es un campo, el conjunto de bandas que declara quien llama: octave_bands() declara fraction=1, porque una sola banda de octava no se distingue de una de tercio de octava por su espaciado. vibration_reduction_index ya no lo rellena con el conjunto de bandas que leía de las frecuencias; lo deja en None, y el resultado lee el espaciado cada vez que calcula la media del anexo A, que da la misma media que antes.

Los números que elige un régimen quedan atados a él, así que un resultado construido a mano ya no puede llevar un régimen junto a los valores de otro. Al construirse, cada uno de estos resultados rechaza:

  • TappingForceResult: una frecuencia de corte, una frecuencia límite, un espectro de fuerza o una potencia inyectada que no sean los que dan K, Zdp y m en su régimen, y unos límites de las ecuaciones (3.99) y (3.100) que no estén a un factor 2 el uno del otro.
  • HydrodynamicValveNoise: una presión de vapor igual o superior a la presión de entrada; un x_F o un x_Fzp1 que no sean los que dan la Ecuación (1) o la (3c) a partir de los campos de al lado; un punto en la evaporación o más allá, x_F = 1; campos de cavitación en un punto turbulento, o ninguno en uno con cavitación.
  • AerodynamicValveNoise: unos límites que no sean los de su gas y su guarnición, y un número de Mach o una eficiencia acústica de otro régimen.
  • TerrainScreeningResult: una fuente o un receptor que no sean un punto finito, una fuente en el receptor o más allá, una sección que no vaya de uno al otro, y una diferencia de camino o unas aristas de difracción que no sean las de la goma elástica sobre esa sección.
  • AutomaticThresholdResult y SweepThresholdResult: inversiones que no se alternan, un trazado que no conserva ningún pico o ningún valle, y una media, un umbral o un umbral continuo que no sean los que dan las inversiones.
  • WaveMotionCorrection: una frecuencia más allá de la última fila de la tabla C.3, y una corrección que la tabla no da en su frecuencia.
  • CabinInsulationResult: un aislamiento ponderado A con cualquier método que no sea el del ruido real.
  • WindTurbineTonalityResult: una candidata que no sea una línea del espectro a 20 Hz o más, y una cadena de las fórmulas 30 a 34 que no sea la que da el espectro en torno a ella.
  • LaboratoryJointInsulationResult: un índice corregido por otra regla de J.1.
  • TurbineSoundLevels: una diferencia de niveles que no sea el total menos el fondo, un nivel del aerogenerador por otra regla de 11.7, y una incertidumbre en un intervalo cuyo nivel no se puede determinar.
  • WestonPropagationResult: una pérdida compuesta que no sea la ley del régimen vigente.
  • SynchronousAverageResult: una rejilla de periodo de más o menos muestras que round(fs * period_s).
import dataclasses
import numpy as np
from phonometry import building
bands = np.array([100.0, 200.0, 400.0, 800.0])
force = building.tapping_force_spectrum(bands, 1.0e6, 3.0e4)
print(force.over_critical)
# False
print(building.tapping_force_spectrum(bands, 1.0e6, 100.0).over_critical)
# True
try:
dataclasses.replace(force, impedance=100.0)
except ValueError as error:
print("cut_off_frequency" in str(error))
# True

Un tipo equivocado lanza TypeError, una clave que falta KeyError, y cada aviso tiene su tema

Sección titulada «Un tipo equivocado lanza TypeError, una clave que falta KeyError, y cada aviso tiene su tema»

La documentación de Python traza la línea entre los dos rechazos: TypeError se lanza «cuando una operación o una función se aplica a un objeto de tipo inapropiado», y ValueError «cuando una operación o una función recibe un argumento que tiene el tipo correcto pero un valor inapropiado». En 3.3.0 y en 4.0.0rc1 setenta y seis rechazos preguntaban el tipo de un argumento y lanzaban ValueError, otros treinta y dos capturaban un TypeError y lo relanzaban como ValueError, y las guardas compartidas de todo parámetro escalar rechazaban así también un array, mientras que unos pocos más lanzaban TypeError por el mismo error. La 4.0 lanza TypeError para un tipo equivocado y ValueError para un tipo correcto con un valor equivocado, en todas partes. Una llamada envuelta en except ValueError para absorber cualquier entrada mala debe capturar (TypeError, ValueError).

Lo que se pasa 3.3.0 o 4.0.0rc1 4.0
un array, None, un texto o un objeto que no es un número donde va un número, en cualquier parámetro escalar ValueError, y un texto que se lee como número, como "20", se tomaba como ese número TypeError, con el nombre del parámetro, tanto para "20" como para "fifty": un texto es del tipo equivocado donde va un número, se lea como se lea
un elemento que no es un número dentro de un array de números ([None, 1.0], ["94.0", "94.1"], un bytearray en un array de objetos) ValueError, y el texto que numpy lee como números se tomaba por ellos TypeError, para un texto se lea como se lea
un texto en cualquier forma que no sea un str (un bytes, un bytearray, un texto o un bytearray dentro de una secuencia o de un array), None donde no es una opción, o un objeto que no es un número, donde una elección junto a números toma sus números: termination= de materials.layered_absorber y materials.diffuse_field_absorption, initial_state= de filters.time_weighting, coefficients= de materials.delany_bazley, target= de room.shaped_sweep_signal, flow_resistivity= de aircraft.terrain_screening_adjustment y aircraft.RotorcraftGround, speech_spectrum= de speech.speech_intelligibility_index un texto que se leía como un número se tomaba por él (termination=["400", "400"] como una impedancia de 400 Pa s/m, coefficients=b"12345678" como los códigos de sus ocho caracteres, speech_spectrum=["60"] * 18 como dieciocho niveles de 60 dB), y el resto fallaba con un error que no nombraba nada, None se leía como nan o el registro lo guardaba TypeError, que nombra el parámetro y sus opciones; RotorcraftGround lo rechaza al construirse. Escribe la opción como un str ("rigid") y los números como números ([400.0, 400.0])
un anidamiento irregular como initial_state= de filters.time_weighting TypeError ValueError, que nombra el parámetro, como para termination= de materials.layered_absorber
un target= de room.shaped_sweep_signal con más o menos de dos arrays los arrays después del segundo quedaban sin leer ValueError, que nombra el parámetro, al empezar la llamada
un número o un array complejo donde va uno real, en cualquier parámetro que leen las guardas compartidas, también initial_state= de filters.time_weighting, incluido un array de objetos que guarda un número complejo de NumPy; un array así entre los valores de escala o las variables correlacionadas de las funciones de paisaje sonoro de environment, y una posición compleja de environment.method_a_scale_values ValueError, y un estado complejo, un array así y una posición compleja de NumPy se leían como su parte real sin más que un ComplexWarning TypeError, que dice que debe ser real
un número complejo de NumPy donde va un número real (np.complex128(343 + 50j)), en cualquier parámetro que leen las guardas compartidas, o dentro de un array de objetos; un valor complejo o un texto en una entrada real de los motores FDTD: un mapa de simulation.FDTD2D o de simulation.ElasticFDTD2D (c, rho, c_p, c_s, damping), dx, cfl, los números de las fuentes y de simulation.Material, simulation.ContourProbe, simulation.ContourPhasors y simulation.far_field_from_contour; cualquier cosa que no sea un único número real (un número complejo, un texto, None, una lista o un array, un bytearray entre ellos) como tiempo t del value(t) de simulation.GaussianPulse, CWSource y SignalSource, o como muestra que devuelve la forma de onda de una fuente mientras avanza un motor se leía su parte real, con no más que un ComplexWarning: el motor elástico avanzaba la parte real de un c_p, un c_s o un rho complejos, o de una muestra compleja de una ExplosionSource o una ForceSource, una PlaneWaveSource fallaba con ella con el error de conversión de NumPy, cada mapa de los dos motores tomaba un texto por el número que escribe (c="343"), y None, una lista o un array como tiempo o como muestra fallaban con un error de Python o de NumPy que no nombraba nada TypeError, que dice que debe ser real, que debe ser números y no texto, o que debe ser un único número real
un valor complejo, un texto o un bytearray entre los números de cualquier parámetro que toma números (un espectro, un eje de frecuencias, una señal, un campo de un registro, un factor de reflexión o una impedancia), y un número complejo de cualquiera de los dos tipos donde va un número, en cualquier parámetro que leen las guardas escalares compartidas un complejo de NumPy o un array complejo se leía como su parte real, con no más que un ComplexWarning (environment.method_b_scale_values(np.complex128(0.5 + 0.3j)) puntuaba la marca de 0,5), mientras que un complejo de Python, solo o en una lista, lanzaba un TypeError sin nombre; se interpretaba un texto (["94.0"] como 94 dB) y un bytearray se leía como los códigos de sus caracteres ([bytearray(b"12")] como niveles de 49 y 50 dB) TypeError, que nombra el parámetro: debe ser real, no complejo, o números, no texto; un parámetro que toma números complejos rechaza solo el texto. Tome el módulo o la parte real de una magnitud compleja antes de la llamada, y escriba los números como números
un texto, unos bytes o un número complejo de NumPy dados como un número a un parámetro que su función leía con float() o complex(), o con el que calculaba antes: temperature_c= de aircraft.npd_atmosphere_increment, una contribución de metrology.combined_standard_uncertainty, la altitud de aircraft.Aerodrome.pressure_ratio, los dos números de aircraft.MeanGroundPlaneResult.equivalent_height, delay= y n= de materials.in_situ_reflection_factor, efficiency_correction de un noise_control.AerodynamicValveNoise que construye usted, y unos trescientos más se interpretaba como el número que escribe (temperature_c="25" como 25 °C, [b"12"] como 12), se leía su parte real, con no más que un ComplexWarning, o, si se calculaba antes con él, daba un TypeError de la aritmética que no nombraba nada TypeError, que nombra el parámetro
un número demasiado grande para un float: un entero de Python como 10**400, o un long double o un Decimal más allá del mayor float, solo o entre los números de un array un OverflowError de la aritmética o de NumPy para un entero, y un infinito, con no más que un aviso, para un long double o un Decimal ValueError, que nombra el parámetro; un infinito que se da se sigue leyendo como tal
un collections.UserString, o un bytes, donde va un par o una lista de etiquetas, de nombres o de índices: shape= de simulation.FDTD2D, excluded= de building.loudest_corner, labels= de filters.FractionalOctaveBands, una contribución de metrology.combined_standard_uncertainty, la lista de un participante de environment.method_b_source_ranking, bands= de environment.bin_amplitude_modulation, ffmpeg_options= de io.VideoOptions, channel_labels= de io.Signal, un material de simulation.scholte_speed y del motor elástico se medía o se partía en sus caracteres (un bytes en sus códigos, así que b"car" ordenaba las fuentes '99', '97' y '114'), y se rechazaba como un valor de longitud equivocada o con un error sobre su anidamiento, o se aceptaba se rechaza como el texto que envuelve, nombrando el parámetro
un collections.UserString, o un bytes, donde un nombre puede valer por una lista de nombres: parameters= de environment.binaural_indicators, targets= de emission.MicrophoneTraverse, vocal_efforts= de speech.standard_speech_spectra, basic_standards= de emission.NoiseEmissionDeclaration se partía en sus caracteres, cada uno rechazado como el nombre de ninguna fila, o se guardaba como una lista de caracteres se rechaza entero por el nombre del parámetro, como algo que no es un texto
un pathlib.Path u otro objeto de ruta como path del .report() de un resultado la ficha se construía y luego fallaba con el error de ReportLab el PDF se escribe ahí, y .report() devuelve la ruta como texto
un índice que no es un entero (un indicador, un float, una fracción, un texto o un array de otro dtype): order= de signals.miso_coherence, los canales de io.Signal.pick se leía con int(): order=(0.5, 1.7) condicionaba las entradas como (0, 1) y order="10" como (1, 0), pick([1.5]) tomaba el canal 1 y pick("01") los canales 0 y 1 TypeError, con el nombre del parámetro
un array de la clase equivocada: una máscara que no es booleana (obstacle_mask= de simulation.FDTD2D y simulation.fdtd_simulation, las máscaras de región de simulation.ElasticFDTD2D.from_regions, valid= de vibration.band_averaged_stiffness), unos line_counts de vibration.BandAveragedStiffness que no son enteros, unos indicadores de exclusión que no son ni booleanos ni enteros (excluded_blocks= de environment.amplitude_modulation_period, excluded= de environment.bin_amplitude_modulation), texto donde van las lecturas, las distancias y las duraciones de las funciones de equipos de servicio de building (building.verify_calibration_deviation, building.check_background_duration y las demás) ValueError TypeError
una secuencia donde va una sola medida: las presiones y las temperaturas de noise_control.normal_air_density, noise_control.total_pressure, noise_control.total_pressure_loss y noise_control.pressure_loss_coefficient, altitude de emission.static_pressure_from_altitude, tolerance_s= de building.check_background_duration ValueError, y las funciones de noise_control leían una secuencia de un elemento como ese elemento TypeError, también una secuencia de un elemento
un número entero (un recuento, un índice, una clase, un número de puntos o de decimales: cualquier parámetro escrito como int) dado como texto, como booleano o como array: signals.zoom_fft(..., n_points=), signals.window_metrics(window, n), signals.min_phase(..., oversample=), electroacoustics.swept_sine_distortion(..., n_harmonics=), metrology.stationarity_test(..., n_segments=), vibration.story_fundamental_frequency(n_stories), n_events= de las funciones de energía acústica y de emission.SoundEnergyResult y emission.ReverberationSoundEnergyResult, n= de building.prediction_input_uncertainty y building.intensity_element_normalized_difference, oversample= de signals.lc_peak y broadcast.true_peak_level, max_order= de room.image_source_rir y room.audible_image_count, los índices de malla y los recuentos de pasos de simulation.FDTD2D, duration_days= de vibration.construction_guide_values, start_band= de aircraft.tone_correction, n_level_ranges= de metrology.SoundLevelMeterFeatures, n_impacts de vibration.ImpactMobilityResult, los recuentos de posiciones de ReportMetadata ValueError, o, donde el valor pasaba por int(), un booleano tomado como 0 o 1, un texto convertido y una fracción truncada sin aviso (n_points=100.6 dibujaba 100 puntos) TypeError. Un número que no es entero, o que queda por debajo del mínimo del recuento, es ValueError, y un flotante entero como 5.0 se toma como 5
un indicador que no es True ni False: small_room= de building.check_service_equipment_positions, absorbing_specimen_surface= del aislamiento de ISO 15186, las declaraciones de la cualificación de campo libre de emission, las prestaciones de metrology.SoundLevelMeterFeatures y las observaciones de metrology.SoundLevelMeterPeriodicMeasurements ValueError TypeError
un nombre que no es texto: los tipos de área, los usos y los periodos de las funciones del RD 1367/2007 y del DB-HR (environment.activity_limits y las demás), los elementos del Anexo A de environment.SoundscapeAcousticEnvironment, las descripciones de emission.turbine_noise_declaration, y cualquier elección entre opciones con nombre dada como algo que no es un texto (period=5) ValueError TypeError; un texto vacío, o uno que no nombra ninguna de las opciones, sigue siendo ValueError
un objeto de la clase equivocada: las cajas de emission.turbine_measurement_surface, surface= de emission.turbine_microphone_positions, correction= de emission.check_turbine_test_environment, las determinaciones de emission.turbine_noise_declaration, las partes de environment.SoundscapeReport, un material del FDTD elástico que no es Material, ni fila de catálogo, ni terna, una waveform que no se puede llamar, un array suelto en io.write(..., sidecar=True), una calibración por bandas donde emission.high_frequency_sound_power_comparison compara tonos ValueError TypeError
un texto donde va una secuencia, un número donde va un par o una lista, o un par que contiene un array: rankings de environment.method_b_source_ranking, bands= de environment.bin_amplitude_modulation, exclude_hz= y los pares de frecuencias de la movilidad de ISO 7626-5, microphones= de las correcciones de IEC 61094-8, los límites de un banco de filtros, shape= de simulation.FDTD2D, los bordes de banda de electroacoustics.LoudspeakerCharacteristics y electroacoustics.MicrophoneCharacteristics ValueError TypeError
un bytearray entero donde va un par, una lista de etiquetas o de índices, o una secuencia de números o de arrays: labels de filters.FractionalOctaveBands, excluded= de building.loudest_corner, band_hz= y los pares de frecuencias de la movilidad de ISO 7626-5, microphones= de las correcciones de IEC 61094-8, los bordes de banda de electroacoustics.LoudspeakerCharacteristics y electroacoustics.MicrophoneCharacteristics, las curvas de electroacoustics.LoudspeakerDirectivity, MicrophoneDirectivity, MicrophoneNoise y MicrophoneOverload, terrain= de aircraft.RotorcraftGround, coefficients= de materials.delany_bazley, shape= de simulation.FDTD2D, simulation.ElasticFDTD2D y simulation.ElasticFDTD2D.from_regions, order= de signals.miso_coherence, los canales de io.Signal.pick, low_band_microphones= de environment.reflection_index; y un mapping o un conjunto donde van esas curvas, ese terreno o esos coeficientes se leía como los códigos de sus caracteres (labels=bytearray(b"1k") como las etiquetas "49" y "107", pick(bytearray(b"\x01")) como el canal 1), como las claves del mapping (coefficients={0: 1.0, ...} como C1 a C8 de 0 a 7) o como los miembros del conjunto sin orden TypeError, que nombra el parámetro
una prestación de hearing.assumed_protection_value o de hearing.hml_rating que no es un número, un clause= de metrology.max_expanded_uncertainty que no es un número, un part= de environment.method_a_scale_values que es un booleano ValueError TypeError; un número que la Tabla 1 no tabula, o un apartado o una parte que no existen, siguen siendo ValueError

Una consulta que no encuentra lo que busca lanza lo que lanza un mapeo cuando el resultado se lee como uno, y ValueError cuando un número cae fuera de lo que cubre:

Lo que se pide 3.3.0 o 4.0.0rc1 4.0
RegulationLimits[period] para un periodo que no guarda ValueError KeyError. La clave se compara tal cual, como la de un dict: limits["Day"] y limits[" night "], que se leían como "day" y "night", ahora también lanzan KeyError. El periodo de environment.PeriodAssessment, que es una elección, sigue lanzando ValueError
emission.measurement_positions("hemisphere", ..., n_reflecting_planes=3, grade="survey") NotImplementedError las posiciones 14, 21 y 22 de la Tabla B.2 de ISO 3746:2010
emission.measurement_positions("hemisphere", ..., grade="survey") sobre un plano reflectante las posiciones 4, 5, 6 y 10 de la Tabla B.1 de ISO 3744, el conjunto para una fuente con tonos las posiciones 4, 5, 6 y 10 de la Tabla B.1 de ISO 3746:2010, las que prescribe el apartado 8.2.1: las posiciones de banda ancha con esos números de la Tabla B.2 de ISO 3744
un instrument= que la tabla C.5 no enumera ("Class 1" por "class1"), en hearing.task_based_exposure, hearing.job_based_exposure y hearing.full_day_exposure KeyError ValueError, y TypeError para un valor que no es texto: el instrumento es una elección, no una clave que el llamador vuelve a leer
fluids.FluidPropertyUnavailable la excepción fluids.FluidPropertyUnavailableError, que sigue siendo un AttributeError, así que hasattr y getattr con un valor por defecto se comportan como antes

Estos avisos derivan ahora de PhonometryWarning, cada uno con un tema propio, así que warnings.simplefilter("error", phonometry.PhonometryWarning) los alcanza a todos y un filtro sobre el tema alcanza a uno. Siguen siendo UserWarning, así que un filtro escrito sobre esa clase sigue casando:

Lo emite 3.3.0 o 4.0.0rc1 4.0
environment.sound_absorption_rating y environment.sound_reflection_rating en el tope de 0,99 environment.RoadDeviceWarning, un UserWarning fuera de la jerarquía environment.RoadDeviceWarning, un PhonometryWarning
building.equivalent_impact_level, building.weighted_lining_improvement y building.lining_improvement fuera del intervalo para el que se enuncia su relación UserWarning building.BuildingPredictionWarning
building.intensity_element_normalized_difference con n > 1 UserWarning building.LaboratoryInsulationWarning
room.room_criterion sobre un espectro al que le falta una banda de 31,5 Hz a 4000 Hz UserWarning room.NoiseCriterionWarning
aircraft.approach_profile ante un paso Level-Idle cuya altitud o CAS de inicio no casa con el paso Level-Idle siguiente (Doc 29 B7.1.4) UserWarning aircraft.FlightProfileWarning, que también avisa ante un paso siguiente que no es Level-Idle ni Descend-Idle (caso 2)
signals.tone_burst cuando fs y frequency son inconmensurables PhonometryWarning signals.ToneBurstWarning
underwater.normal_modes, underwater.eigenrays y underwater.gaussian_beams PhonometryWarning underwater.NumericalPropagationWarning
un banco de filtros que descarta las bandas por encima de la frecuencia de Nyquist (Low sampling rate) PhonometryWarning filters.FilterBankWarning
import phonometry
from phonometry import environment, vibration
limits = environment.activity_limits("a")
try:
limits["noon"]
except KeyError:
print("KeyError")
for n_stories in ("5", 2.5):
try:
vibration.story_fundamental_frequency(n_stories)
except (TypeError, ValueError) as refusal:
print(type(refusal).__name__)
print(issubclass(environment.RoadDeviceWarning, phonometry.PhonometryWarning))
# KeyError
# TypeError
# ValueError
# True

Un aviso nombra la línea de tu código que lo causó

Sección titulada «Un aviso nombra la línea de tu código que lo causó»

Cada aviso de la biblioteca se muestra ahora en la primera línea del código de quien llama, sean cuales sean las funciones de la biblioteca por las que se llegó a él. La acción default de Python lo muestra entonces una vez por cada línea tuya que lo causa, y un filtro por módulo lee tu módulo. Una traza nombra el aviso por el paquete que lo exporta:

Qué 3.3.0 o 4.0.0rc1 4.0
el fichero y la línea en que se muestra un aviso la línea hasta la que contaba su stacklevel, una línea de la biblioteca en 33 de ellos, como filters/core.py:698 para cada banco de filtros que descartaba una banda la línea de tu código que hizo la llamada
warnings.filterwarnings("ignore", module="phonometry") silenciaba los avisos mostrados en una línea de la biblioteca, y ningún otro no silencia ninguno; filtra por clase, warnings.filterwarnings("ignore", category=phonometry.PhonometryWarning), o por tema
warnings.filterwarnings("error", module="my_analysis") no alcanzaba los avisos mostrados en una línea de la biblioteca alcanza cada aviso que causa una llamada de my_analysis
filters.OctaveFilterBank(44100), filters.octave_filter(x, 44100) y los demás bancos sobre el intervalo por defecto, a una frecuencia de muestreo que no admite sus bandas altas (44,1, 32, 22,05, 16 u 8 kHz) FilterBankWarning: Low sampling rate: frequencies above fs/2 removed ningún aviso, y las mismas bandas: el intervalo por defecto se recorta a lo que admite fs
un banco sobre unos limits que das y pasan de fs/2 el mismo aviso, sólo en la primera llamada, porque el diseño se guarda en caché FilterBankWarning: Low sampling rate: fs = 44100 Hz cannot hold the 20 kHz band, whose upper edge 22387 Hz is above fs/2 = 22050 Hz; it was left out of the bank., en cada llamada; un filtro sobre el mensaje Low sampling rate sigue casando
un banco a una frecuencia de muestreo que no admite ninguna banda de su intervalo, el de por defecto o el tuyo, como filters.OctaveFilterBank(20, fraction=3) FilterBankWarning: Low sampling rate: frequencies above fs/2 removed, y un banco sin bandas cuyo análisis volvía vacío ValueError: fs = 20 Hz cannot hold any band from 12.5 Hz to 20 kHz: the upper edge of the lowest, 14.13 Hz, is above fs/2 = 10 Hz.
vibration.transfer_stiffness_indirect con una transmisibilidad que contiene inf o nan un array con -inf+nanj ValueError: 'transmissibility' must contain only finite values.
el nombre que dan una traza, un repr o pickle a los 14 avisos escritos en módulos privados, PhonometryWarning entre ellos el módulo privado, phonometry.fluids._state.FluidAssumptionWarning el paquete que lo exporta, phonometry.fluids.FluidAssumptionWarning; la clase es la misma, e inspect.getsource sobre ella lanza OSError

Un parámetro o un campo de registro tipado con un Literal de sus opciones, cuyo código limpiaba el texto antes de comprobarlo, acepta ahora las grafías que ese Literal enumera, y solo esas. Antes de 4.0, 198 de ellos cambiaban mayúsculas y minúsculas, quitaban espacios, intercambiaban _, - y espacios, traducían un alias propio o convertían en texto cualquier valor con str() antes de buscar la opción, de modo que una llamada que un comprobador de tipos rechazaba se ejecutaba igualmente: filters.WeightingFilter(48000, "a"), filters.time_weighting(x, fs, mode="FAST"), vibration.guide_values("residential", edition=1999). Otros dos leían una opción y tomaban cualquier otro valor por la segunda: el onset_rate_method de environment.detect_onsets y de environment.impulsive_sound_adjustment ajustaba como mínimos cuadrados todo lo que no fuera "upper_half". En 4.0 esa llamada lanza ValueError, o TypeError para un valor que no es texto, y el arreglo es escribir la opción tal como la enumera su Literal. Los alias que un Literal enumera a propósito siguen valiendo: "docente" por "educational" en building.db_hr_facade_requirement, "dnt_w" por "r_w" en building.single_number_uncertainty. Los ficheros que lee la biblioteca, como una base de datos ANP, se siguen leyendo escriban sus palabras con las mayúsculas que escriban.

from phonometry import filters
try:
filters.WeightingFilter(48000, "a")
except ValueError as refusal:
print(type(refusal).__name__)
print(filters.WeightingFilter(48000, "A").weighting)
# ValueError
# A

Cada fila es un parámetro que dejó de aceptar una grafía, con un ejemplo de cada clase que aceptaba y todos sus alias propios. Los ejemplos salen de ejecutar, con la grafía cambiada, las llamadas que hace la batería de pruebas y unas pocas escritas a propósito, sobre el código justo anterior a 4.0. Algunos de los parámetros son posteriores a 4.0.0rc1, o se renombraron después; sus filas solo afectan al código escrito desde entonces.

Parámetro Aceptaba antes de 4.0 4.0 lanza
aircraft.ANPAircraft.event_level(metric=) otras mayúsculas ("EXPOSURE" por "exposure"); espacios alrededor (" exposure " por "exposure") ValueError
aircraft.ANPAircraft.event_level(operation=) otras mayúsculas ("DEPARTURE" por "departure"); espacios alrededor (" departure " por "departure"); alias propios ("a", "approach", "arrivals", "d", "departures", "landing", "take-off", "takeoff"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
aircraft.ANPAircraft.noise_contour(metric=) otras mayúsculas ("EXPOSURE" por "exposure"); espacios alrededor (" exposure " por "exposure") ValueError
aircraft.ANPAircraft.noise_contour(operation=) otras mayúsculas ("DEPARTURE" por "departure"); espacios alrededor (" departure " por "departure"); alias propios ("a", "approach", "arrivals", "d", "departures", "landing", "take-off", "takeoff"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
aircraft.ANPAircraft.npd_curves(operation=) otras mayúsculas ("DEPARTURE" por "departure"); espacios alrededor (" departure " por "departure"); alias propios ("a", "approach", "arrivals", "d", "departures", "landing", "take-off", "takeoff"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
aircraft.ANPAircraft.profile(operation=) otras mayúsculas ("DEPARTURE" por "departure"); espacios alrededor (" departure " por "departure"); alias propios ("a", "approach", "arrivals", "d", "departures", "landing", "take-off", "takeoff"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
aircraft.ANPAircraft.revised_npd_curves(operation=) otras mayúsculas ("DEPARTURE" por "departure"); espacios alrededor (" departure " por "departure"); alias propios ("a", "approach", "arrivals", "d", "departures", "landing", "take-off", "takeoff"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
aircraft.ANPAircraft.spectral_class(operation=) otras mayúsculas ("DEPARTURE" por "departure"); espacios alrededor (" departure " por "departure"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
aircraft.ANPDatabase.event_level(metric=) otras mayúsculas ("EXPOSURE" por "exposure"); espacios alrededor (" exposure " por "exposure") ValueError
aircraft.ANPDatabase.event_level(operation=) otras mayúsculas ("DEPARTURE" por "departure"); espacios alrededor (" departure " por "departure"); alias propios ("a", "approach", "arrivals", "d", "departures", "landing", "take-off", "takeoff"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
aircraft.ANPDatabase.flight_profile(operation=) otras mayúsculas ("DEPARTURE" por "departure"); espacios alrededor (" departure " por "departure"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
aircraft.ANPDatabase.noise_contour(metric=) otras mayúsculas ("EXPOSURE" por "exposure"); espacios alrededor (" exposure " por "exposure") ValueError
aircraft.ANPDatabase.noise_contour(operation=) otras mayúsculas ("DEPARTURE" por "departure"); espacios alrededor (" departure " por "departure"); alias propios ("a", "approach", "arrivals", "d", "departures", "landing", "take-off", "takeoff"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
aircraft.ANPDatabase.npd_curves(operation=) otras mayúsculas ("DEPARTURE" por "departure"); espacios alrededor (" A " por "A"); alias propios ("a", "approach", "arrivals", "d", "departures", "landing", "take-off", "takeoff"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
aircraft.ANPDatabase.procedural_profile(operation=) otras mayúsculas ("DEPARTURE" por "departure"); espacios alrededor (" departure " por "departure"); alias propios ("a", "approach", "arrivals", "d", "departures", "landing", "take-off", "takeoff"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
aircraft.ANPDatabase.procedural_steps(operation=) otras mayúsculas ("DEPARTURE" por "departure"); espacios alrededor (" departure " por "departure"); alias propios ("a", "approach", "arrivals", "d", "departures", "landing", "take-off", "takeoff"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
aircraft.ANPDatabase.profile(operation=) otras mayúsculas ("DEPARTURE" por "departure"); espacios alrededor (" departure " por "departure"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
aircraft.ANPDatabase.revised_npd_curves(operation=) otras mayúsculas ("DEPARTURE" por "departure"); espacios alrededor (" departure " por "departure"); alias propios ("a", "approach", "arrivals", "d", "departures", "landing", "take-off", "takeoff"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
aircraft.AircraftSystemComplianceResult(linearity=) claves que no son texto pero se escriben como opciones TypeError para un valor que no es texto
aircraft.PerformanceAircraft.flap(operation=) otras mayúsculas ("d" por "D"); espacios alrededor (" D " por "D"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
aircraft.engine_installation_correction(mounting=) otras mayúsculas ("WING" por "wing"); espacios alrededor (" wing " por "wing"); alias propios ("prop") ValueError
aircraft.event_level(metric=) otras mayúsculas ("EXPOSURE" por "exposure"); espacios alrededor (" exposure " por "exposure") ValueError
aircraft.event_level(mounting=) otras mayúsculas ("WING" por "wing"); espacios alrededor (" wing " por "wing") ValueError
aircraft.ground_effect_adjustment(flow_resistivity=) otras mayúsculas ("g" por "G"); espacios alrededor (" G " por "G") ValueError
aircraft.noise_contour(metric=) otras mayúsculas ("EXPOSURE" por "exposure"); espacios alrededor (" exposure " por "exposure") ValueError
aircraft.noise_contour(mounting=) otras mayúsculas ("WING" por "wing"); espacios alrededor (" wing " por "wing") ValueError
aircraft.start_of_roll_directivity(engine=) otras mayúsculas ("JET" por "jet"); espacios alrededor (" jet " por "jet"); alias propios ("prop", "propeller", "turbofan") ValueError
aircraft.terrain_screening_adjustment(flow_resistivity=) otras mayúsculas ("d" por "D"); espacios alrededor (" D " por "D") ValueError
building.d2m_nt_a(spectrum=) otras mayúsculas ("RAILWAY" por "railway"); espacios alrededor (" railway " por "railway"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
building.d2m_nt_atr(spectrum=) otras mayúsculas ("TRAFFIC" por "traffic"); espacios alrededor (" traffic " por "traffic"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
building.db_hr_airborne_requirement(receiving_room=) otras mayúsculas ("PROTECTED" por "protected"); espacios alrededor (" protected " por "protected"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
building.db_hr_airborne_requirement(source_room=) otras mayúsculas ("SAME_UNIT" por "same_unit"); espacios alrededor (" same_unit " por "same_unit"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
building.db_hr_facade_requirement(building_use=) otras mayúsculas ("RESIDENTIAL" por "residential"); espacios alrededor (" residential " por "residential") ValueError
building.db_hr_facade_requirement(dominant_noise=) otras mayúsculas ("ROAD" por "road"); espacios alrededor (" road " por "road"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
building.db_hr_facade_requirement(room_type=) otras mayúsculas ("BEDROOMS" por "bedrooms"); espacios alrededor (" bedrooms " por "bedrooms") ValueError
building.db_hr_global_index(spectrum=) otras mayúsculas ("PINK" por "pink"); espacios alrededor (" pink " por "pink"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
building.db_hr_impact_requirement(receiving_room=) otras mayúsculas ("PROTECTED" por "protected"); espacios alrededor (" protected " por "protected"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
building.db_hr_impact_requirement(source_room=) otras mayúsculas ("OTHER_UNIT" por "other_unit"); espacios alrededor (" other_unit " por "other_unit"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
building.db_hr_reverberation_requirement(room_use=) otras mayúsculas ("CLASSROOM" por "classroom"); espacios alrededor (" classroom " por "classroom"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
building.estimate_reverberation_index(room=) otras mayúsculas ("G" por "g"); espacios alrededor (" g " por "g"); alias propios ("other", "others") ValueError
building.single_number_uncertainty(quantity=) otras mayúsculas ("R_W" por "r_w"); espacios alrededor (" r_w " por "r_w") ValueError
building.uncertain_value(quantity=) otras mayúsculas ("R_W" por "r_w"); espacios alrededor (" r_w " por "r_w") ValueError
environment.activity_limits(area_type=) otras mayúsculas ("A" por "a"); espacios alrededor (" a " por "a") ValueError
environment.adjacent_premises_limits(building_use=) otras mayúsculas ("RESIDENTIAL" por "residential"); espacios alrededor (" residential " por "residential") ValueError
environment.adjacent_premises_limits(room_type=) otras mayúsculas ("BEDROOMS" por "bedrooms"); espacios alrededor (" bedrooms " por "bedrooms") ValueError
environment.assess_activity(period_hours=) otras mayúsculas (claves: {"Day": 12.0}); espacios alrededor (claves: {" day ": 12.0}); claves que no son texto pero se escriben como opciones ValueError, y TypeError para un valor que no es texto
environment.bridge_transfer(bridge=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
environment.detect_onsets(onset_rate_method=) cualquier valor: todo lo que no fuera exactamente "upper_half" se ajustaba como "least_squares" ("UPPER_HALF", " upper_half ", "banana", 5) ValueError, y TypeError para un valor que no es texto
environment.impulsive_sound_adjustment(onset_rate_method=) cualquier valor: todo lo que no fuera exactamente "upper_half" se ajustaba como "least_squares" ("UPPER_HALF", " upper_half ", "banana", 5) ValueError, y TypeError para un valor que no es texto
environment.indoor_quality_objectives(building_use=) otras mayúsculas ("RESIDENTIAL" por "residential"); espacios alrededor (" residential " por "residential") ValueError
environment.indoor_quality_objectives(room_type=) otras mayúsculas ("LIVING" por "living"); espacios alrededor (" living " por "living") ValueError
environment.infrastructure_limits(area_type=) otras mayúsculas ("E" por "e"); espacios alrededor (" e " por "e") ValueError
environment.max_infrastructure_limit(area_type=) otras mayúsculas ("E" por "e"); espacios alrededor (" e " por "e") ValueError
environment.measured_insertion_loss_indirect(receiver_type_after=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
environment.measured_insertion_loss_indirect(receiver_type_before=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
environment.outdoor_quality_objectives(area_type=) otras mayúsculas ("E" por "e"); espacios alrededor (" e " por "e") ValueError
environment.outdoor_quality_objectives(urbanization=) otras mayúsculas ("EXISTING" por "existing"); espacios alrededor (" existing " por "existing"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
environment.pass_by_regression(vehicle_category=) espacios alrededor (" 1 " por "1"); un número (1 por "1"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
environment.rail_roughness(roughness=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
environment.road_propulsion_noise(category=) un número (1 por "1"); un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
environment.road_propulsion_noise(surface=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
environment.road_rolling_noise(category=) un número (1 por "1"); un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
environment.road_rolling_noise(surface=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
environment.road_source_power(surface=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
environment.road_surface_coefficients(surface=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
environment.road_vehicle_sound_power(category=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
environment.road_vehicle_sound_power(surface=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
environment.statistical_pass_by(corrected_vehicle_sound_levels=) otras mayúsculas (claves: {"1": 78.8, "2A": 81.1, "2B": 83.8}); espacios alrededor (claves: {" 1 ": 78.8, " 2a ": 81.1, " 2b ": 83.8}); claves que no son texto pero se escriben como opciones ValueError, y TypeError para un valor que no es texto
environment.statistical_pass_by(reference_levels=) otras mayúsculas (claves: {"1": 80.0, "2A": 85.0, "2B": 89.0}); espacios alrededor (claves: {" 1 ": 80.0, " 2a ": 85.0, " 2b ": 89.0}); claves que no son texto pero se escriben como opciones ValueError, y TypeError para un valor que no es texto
environment.statistical_pass_by(weighting_factors=) otras mayúsculas (claves: {"1": 0.9, "2A": 0.075, "2B": 0.025}); espacios alrededor (claves: {" 1 ": 0.9, " 2a ": 0.075, " 2b ": 0.025}); claves que no son texto pero se escriben como opciones ValueError, y TypeError para un valor que no es texto
environment.statistical_pass_by_index(vehicle_sound_levels=) otras mayúsculas (claves: {"1": 78.5, "2A": 81.1, "2B": 83.8}); espacios alrededor (claves: {" 1 ": 78.5, " 2a ": 81.1, " 2b ": 83.8}); claves que no son texto pero se escriben como opciones ValueError, y TypeError para un valor que no es texto
environment.statistical_pass_by_index(weighting_factors=) otras mayúsculas (claves: {"1": 0.8, "2A": 0.1, "2B": 0.1}); espacios alrededor (claves: {" 1 ": 0.8, " 2a ": 0.1, " 2b ": 0.1}); claves que no son texto pero se escriben como opciones ValueError, y TypeError para un valor que no es texto
environment.track_transfer(track=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
environment.traction_sound_power(vehicle=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
environment.vibration_quality_objective(building_use=) otras mayúsculas ("RESIDENTIAL" por "residential"); espacios alrededor (" residential " por "residential") ValueError
environment.wheel_roughness(brake=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
filters.OctaveFilterBank.filter(mode=) otras mayúsculas ("RMS" por "rms") ValueError
filters.OctaveFilterBank.spectrogram(mode=) otras mayúsculas ("RMS" por "rms") ValueError
filters.TimeWeighting(mode=) otras mayúsculas ("FAST" por "fast") ValueError
filters.WeightingFilter(weighting=) otras mayúsculas ("a" por "A") ValueError
filters.time_weighting(initial_state=) otras mayúsculas ("ZERO" por "zero") ValueError
filters.time_weighting(mode=) otras mayúsculas ("FAST" por "fast") ValueError
fluids.sea_water(sound_speed_model=) otras mayúsculas ("UNESCO" por "unesco"); espacios alrededor (" unesco " por "unesco") ValueError
fluids.sea_water_sound_speed(model=) otras mayúsculas ("MACKENZIE" por "mackenzie"); espacios alrededor (" mackenzie " por "mackenzie") ValueError
materials.check_ceiling_specimen(mounting=) otras mayúsculas ("e" por "E"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
materials.mounting_type(letter=) otras mayúsculas ("e" por "E"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
metrology.CalibratorTableRow.for_class(calibrator_class=) otras mayúsculas ("1/m" por "1/M"); espacios alrededor (" 1 " por "1"); un número (1 por "1"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
metrology.sensitivity(calibrator_class=) espacios alrededor (" 1 " por "1"); un número (1 por "1"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
metrology.verify_sound_calibrator(calibrator_class=) espacios alrededor (" 1 " por "1"); un número (1 por "1"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
metrology.verify_sound_calibrator(environmental_test=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
noise_control.applicable_methods(condition=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
noise_control.applicable_methods(source_kind=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
noise_control.cabin_insulation(method=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
noise_control.check_enclosure_test_environment(base_standard=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
noise_control.enclosure_artificial_source_insulation(condition=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
noise_control.enclosure_artificial_source_insulation(quantity=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
noise_control.enclosure_sound_power_insulation(condition=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
noise_control.enclosure_sound_power_insulation(source_kind=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
noise_control.enclosure_sound_pressure_insulation(condition=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
noise_control.enclosure_sound_pressure_insulation(source_kind=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
noise_control.screen_attenuation(source_kind=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
noise_control.uncertainty_conditions(method=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
noise_control.weighted_cabin_insulation(method=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
noise_control.weighted_enclosure_insulation(quantity=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
signals.ln_levels(mode=) otras mayúsculas ("FAST" por "fast") ValueError
signals.ln_levels(weighting=) otras mayúsculas ("a" por "A") ValueError
signals.sel(weighting=) otras mayúsculas ("a" por "A") ValueError
underwater.VolumeAbsorption(model=) otras mayúsculas ("THORP" por "thorp"); espacios alrededor (" thorp " por "thorp"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
underwater.WeightedExposureResult(group=) otras mayúsculas ("vhf" por "VHF"); espacios alrededor (" VHF " por "VHF"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
underwater.WeightedExposureResult(guidance=) otras mayúsculas ("NMFS-2024" por "nmfs-2024"); espacios alrededor (" nmfs-2024 " por "nmfs-2024"); otro separador ("nmfs_2024" por "nmfs-2024"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
underwater.audiogram_parameters(group=) otras mayúsculas ("hf" por "HF"); espacios alrededor (" HF " por "HF"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
underwater.auditory_weighting(group=) otras mayúsculas ("hf" por "HF"); espacios alrededor (" HF " por "HF"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
underwater.auditory_weighting(guidance=) otras mayúsculas ("NMFS-2018" por "nmfs-2018"); espacios alrededor (" nmfs-2018 " por "nmfs-2018"); otro separador ("nmfs_2018" por "nmfs-2018"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
underwater.detection_range(law=) otras mayúsculas ("SPHERICAL" por "spherical"); espacios alrededor (" spherical " por "spherical") ValueError
underwater.detection_range(model=) otras mayúsculas ("FRANCOIS-GARRISON" por "francois-garrison"); espacios alrededor (" francois-garrison " por "francois-garrison") ValueError
underwater.detection_range_from_curve(crossing=) otras mayúsculas ("FIRST" por "first"); espacios alrededor (" first " por "first") ValueError
underwater.effective_depth(seabed=) otras mayúsculas ("SAND" por "sand"); espacios alrededor (" sand " por "sand"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
underwater.eigenrays(bottom=) otras mayúsculas ("PRESSURE-RELEASE" por "pressure-release"); espacios alrededor (" pressure-release " por "pressure-release") ValueError
underwater.exposure_criteria(group=) otras mayúsculas ("lf" por "LF"); espacios alrededor (" LF " por "LF"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
underwater.exposure_criteria(guidance=) otras mayúsculas ("SOUTHALL-2019" por "southall-2019"); espacios alrededor (" southall-2019 " por "southall-2019"); otro separador ("southall_2019" por "southall-2019"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
underwater.gaussian_beams(bottom=) otras mayúsculas ("RIGID" por "rigid"); espacios alrededor (" rigid " por "rigid") ValueError
underwater.group_audiogram(group=) otras mayúsculas ("hf" por "HF"); espacios alrededor (" HF " por "HF"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
underwater.hearing_groups(guidance=) otras mayúsculas ("SOUTHALL-2019" por "southall-2019"); espacios alrededor (" southall-2019 " por "southall-2019"); otro separador ("southall_2019" por "southall-2019"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
underwater.normal_modes(bottom=) otras mayúsculas ("PRESSURE-RELEASE" por "pressure-release"); espacios alrededor (" pressure-release " por "pressure-release") ValueError
underwater.propagation_loss(law=) otras mayúsculas ("SPHERICAL" por "spherical"); espacios alrededor (" spherical " por "spherical") ValueError
underwater.propagation_loss(model=) otras mayúsculas ("FRANCOIS-GARRISON" por "francois-garrison"); espacios alrededor (" francois-garrison " por "francois-garrison") ValueError
underwater.reflection_loss_gradient(seabed=) otras mayúsculas ("SAND" por "sand"); espacios alrededor (" sand " por "sand"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
underwater.seawater_absorption(model=) otras mayúsculas ("THORP" por "thorp"); espacios alrededor (" thorp " por "thorp") ValueError
underwater.ship_source_spectrum(model=) otras mayúsculas ("JOMOPANS-ECHO" por "jomopans-echo"); espacios alrededor (" jomopans-echo " por "jomopans-echo") ValueError
underwater.ship_source_spectrum(vessel_class=) otras mayúsculas ("BULKER" por "bulker"); espacios alrededor (" bulker " por "bulker"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
underwater.sound_speed_profile(model=) otras mayúsculas ("MEDWIN" por "medwin"); espacios alrededor (" medwin " por "medwin") ValueError
underwater.spreading_loss(law=) otras mayúsculas ("SPHERICAL" por "spherical"); espacios alrededor (" spherical " por "spherical") ValueError
underwater.waveguide_cutoff_frequency(seabed=) otras mayúsculas ("SAND" por "sand"); espacios alrededor (" sand " por "sand"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
underwater.weighted_exposure(group=) otras mayúsculas ("vhf" por "VHF"); espacios alrededor (" VHF " por "VHF"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
underwater.weighted_exposure(guidance=) otras mayúsculas ("NMFS-2024" por "nmfs-2024"); espacios alrededor (" nmfs-2024 " por "nmfs-2024"); otro separador ("nmfs_2024" por "nmfs-2024"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
underwater.weighting_parameters(group=) otras mayúsculas ("hf" por "HF"); espacios alrededor (" HF " por "HF"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
underwater.weighting_parameters(guidance=) otras mayúsculas ("NMFS-2018" por "nmfs-2018"); espacios alrededor (" nmfs-2018 " por "nmfs-2018"); otro separador ("nmfs_2018" por "nmfs-2018"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
underwater.weston_propagation_loss(seabed=) otras mayúsculas ("SAND" por "sand"); espacios alrededor (" sand " por "sand"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
underwater.weston_regime_boundaries(seabed=) otras mayúsculas ("SAND" por "sand"); espacios alrededor (" sand " por "sand"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
vibration.PhaseVerification(weighting=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.RunningRMSDecayVerification(method=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.WeightingVerification(weighting=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.admissible_exposure_s(time_of_day=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.angular_average_transmission_coefficient(junction=) otras mayúsculas ("x" por "X"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
vibration.angular_average_transmission_coefficient(section=) otras mayúsculas ("CORNER" por "corner"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
vibration.assess_people_in_buildings(source=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.assess_railway_change(time_of_day=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.assessment_vibration_severity(time_of_day=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.band_limited_weighting_factor(name=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.check_loose_mounting(direction=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.check_loose_mounting(surface=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.construction_guide_values(area=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.construction_guide_values(stage=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.corner_transmission_coefficient(junction=) otras mayúsculas ("x" por "X"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
vibration.foundation_to_floor_level_difference(floor=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.foundation_to_floor_level_difference(statistic=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.geometric_exponent(character=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.geometric_exponent(geometry=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.geometric_exponent(wave=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.ground_to_floor_level_difference(floor=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.ground_to_foundation_level_difference(level=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.ground_to_foundation_level_difference(statistic=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.guide_values(area=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.guide_values(edition=) un número (1999 por "1999"); un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.guide_values(source=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.guide_values(time_of_day=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.indication_tolerance_percent(name=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.instrument_confidence_limit_percent(quantity=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.junction_transmission(junction=) otras mayúsculas ("l" por "L"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
vibration.kb_fmax_from_peak_velocity(kind=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.phase_tolerance_deg(name=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.railway_assessment_severity(time_of_day=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.railway_guide_values(alignment=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.railway_guide_values(area=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.railway_guide_values(time_of_day=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.reference_indication(name=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.running_rms_decay_time(method=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.sawtooth_burst(application=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.signal_burst_indications(application=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.signal_burst_indications(name=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.straight_transmission_coefficient(junction=) otras mayúsculas ("t1" por "T1"); un valor que no es texto pero se escribe como una opción ValueError, y TypeError para un valor que no es texto
vibration.train_assessment_severity(time_of_day=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.train_decay_exponent(fitted_with=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.train_weighting_factor(alignment=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.train_weighting_factor(kind=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.verify_phase_response(name=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.verify_running_rms_decay(method=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.verify_signal_burst_response(application=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.verify_signal_burst_response(name=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.verify_weighting(name=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto
vibration.weighting_tolerance_percent(name=) un valor que no es texto pero se escribe como una opción TypeError para un valor que no es texto

Un registro rechaza una opción al construirse

Sección titulada «Un registro rechaza una opción al construirse»

Un registro que construye quien llama comprueba en su __post_init__, tal como se escribe, cada campo tipado con un Literal: un texto que no ofrece lanza ValueError y un valor que no es texto lanza TypeError, al construir el registro. Antes de 4.0 la mayoría guardaba cualquier valor y lo dejaba a quien lo leyera, de modo que una errata fallaba más tarde, en otra llamada, o no fallaba; los cuatro que sí comprobaban rechazaban con ValueError un valor que no es texto. El arreglo es escribir la opción tal como la enumera su Literal donde se construye el registro.

Registro Antes de 4.0 4.0
aircraft.ANPNPDCurves(metric=, operation=) guardaba cualquier valor, rechazado más tarde o nunca rechazado al construirse
aircraft.SpectralClass(operation=) guardaba cualquier valor, rechazado más tarde o nunca rechazado al construirse
aircraft.RotorcraftAtmosphere(atmospheric_method=) guardaba cualquier valor, rechazado más tarde o nunca rechazado al construirse
aircraft.RotorcraftGround(flow_resistivity=) guardaba cualquier valor, rechazado más tarde o nunca ValueError para una letra que no ofrece y para un número que no es positivo y finito, TypeError para un valor que no es ni una letra ni números (un bytes, None, un valor complejo, un texto entre números), al construirse
building.BandPath(kind=) guardaba cualquier valor, rechazado más tarde o nunca rechazado al construirse
building.FlankingPath(kind=) guardaba cualquier valor, rechazado más tarde o nunca rechazado al construirse
electroacoustics.MicrophoneNoise(weighting=) guardaba cualquier valor, rechazado más tarde o nunca rechazado al construirse
emission.MicrophoneTraverse(targets=) ValueError para cualquier objetivo que no conocía, texto o no ValueError para un texto que no ofrece, TypeError para un objetivo que no es texto
environment.BinnedSoundLevels(averaging=) guardaba cualquier valor, rechazado más tarde o nunca rechazado al construirse
environment.RoadEmissionCoefficients (las claves de categoría de sus tablas por categoría) guardaba cualquier clave, rechazada más tarde o nunca ValueError para un texto que no es un código de la Tabla [2.2.a], TypeError para una clave que no es texto, cada clave al construirse
environment.RoadSurfaceCoefficients(alpha=, beta=) (sus claves de categoría) guardaba cualquier clave, rechazada más tarde o nunca ValueError para un texto que no es un código de la Tabla [2.2.a], TypeError para una clave que no es texto, cada clave al construirse
filters.FilterDesign(filter_type=) guardaba cualquier valor, rechazado más tarde o nunca rechazado al construirse
filters.EQSection(filter_type=) ValueError para cualquier valor que no conocía, texto o no ValueError para un texto que no ofrece, TypeError para un valor que no es texto
hearing.Task(instrument=) guardaba cualquier valor, rechazado más tarde o nunca rechazado al construirse
materials.FiberResistivityFit(direction=) guardaba cualquier valor, rechazado más tarde o nunca rechazado al construirse
metrology.SoundLevelMeterPeriodicMeasurements (las claves de sus diccionarios por ponderación, por rango y por respuesta) ValueError para cualquier clave que no conocía ValueError para un texto que no conoce, TypeError para una clave que no es texto, cada clave al construirse
noise_control.DesignCriterion(family=) guardaba cualquier valor, rechazado más tarde o nunca rechazado al construirse
noise_control.SourceRoom(model=) guardaba cualquier valor, rechazado más tarde o nunca rechazado al construirse
noise_control.LiquidTrim(coefficient=) guardaba cualquier valor, rechazado más tarde o nunca rechazado al construirse
noise_control.ValveTrim(coefficient=) guardaba cualquier valor, rechazado más tarde o nunca rechazado al construirse
phonometry.ReportMetadata(tube_shape=) ValueError para cualquier valor que no conocía, texto o no ValueError para un texto que no ofrece, TypeError para un valor que no es texto
simulation.ElasticBoundaries(sides=) guardaba cualquier valor; la ejecución que contenía el registro rechazaba un lado o un nombre desconocido con ValueError, fuera texto o no ValueError para un lado o un nombre que no ofrece, TypeError para uno que no es texto, al construirse
simulation.FDTDBoundaries(sides=) guardaba cualquier valor; la ejecución que contenía el registro rechazaba un lado o un nombre desconocido con ValueError, fuera texto o no, ejecutaba un booleano como una impedancia de 1 Pa s/m y rechazaba None como una impedancia que no es finita ValueError para un lado o un nombre que no ofrece, TypeError para un lado que no es texto y para una terminación que no es un nombre ni un número real ni un array de ellos (un booleano, None, un booleano entre los números de un perfil), al construirse; una impedancia se guarda como un float, y un perfil como un array float64 de solo lectura
simulation.ElasticRecording(probe_fields=, snapshot_field=) ValueError para cualquier campo que no conociera, fuera texto o no; probe_fields="vy" se leía letra a letra y rechazaba "v" ValueError para un texto que no ofrece, TypeError para un campo que no es texto; un solo nombre registra ese campo
simulation.ForceSource(direction=) ValueError para cualquier dirección que no conociera, fuera texto o no ValueError para un texto distinto de "x" y "y", TypeError para un valor que no es texto
simulation.PlaneWaveSource(direction=) guardaba cualquier valor; FDTD2D.add_source y la ejecución que lo contenía rechazaban uno que no conocían rechazado al construirse
vibration.GuideValues(time_of_day=, edition=) guardaba cualquier valor, rechazado más tarde o nunca rechazado al construirse
vibration.FaultLine(family=) guardaba cualquier valor, rechazado más tarde o nunca rechazado al construirse

Las funciones comprueban también la opción en todos los caminos. Una que se leía solo en algunos caminos aceptaba cualquier valor en los demás, y una que se comprobaba con una comparación rechazaba con ValueError un valor que no es texto, o con un error ajeno:

Llamada Antes de 4.0 4.0
environment.ground_effect(model=) aceptaba cualquier valor sin flow_resistivity_pa_s_m2 ValueError para un texto que no ofrece, TypeError para un valor que no es texto, se dé lo que se dé
environment.barrier_insertion_loss(ground_model=) aceptaba cualquier valor sin ground_flow_resistivity_pa_s_m2 lo mismo
environment.atmospheric_parabolic_equation(model=) aceptaba cualquier valor sin flow_resistivity_pa_s_m2 lo mismo
metrology.coupler_transfer_impedance(heat_conduction_method=) aceptaba cualquier valor con un PlaneWaveCoupler lo mismo
noise_control.elbow_insertion_loss(lined_side=) aceptaba cualquier valor con model="ashrae" lo mismo
noise_control.fan_sound_power(assembly=) aceptaba cualquier valor con model="ashrae" lo mismo
noise_control.fan_sound_power(fan_type=) aceptaba cualquier valor con model="vdi2081" lo mismo
signals.time_delay(weighting=) aceptaba cualquier valor salvo con method="gcc" lo mismo
underwater.ship_source_spectrum(vessel_class=) aceptaba cualquier valor salvo con model="jomopans-echo" lo mismo
emission.reference_source_calibration(arrangement=), emission.reference_source_reproducibility(arrangement=) aceptaba cualquier valor en una cámara reverberante lo mismo; allí se sigue aceptando None
building.single_number_uncertainty(situation=) con upper_limit=True ValueError para todo lo que no fuera "A", texto o no ValueError para un texto distinto de "A", TypeError para un valor que no es texto
io.write(subtype=) con muestras enteras ValueError para todo lo que no fuera el subtipo propio de las muestras, texto o no TypeError para un valor que no es texto
io.write_catalogue(delimiter=, decimal=) junto a un documento JSON ValueError para todo lo que no fuera el dialecto por defecto, texto o no TypeError para un valor que no es texto
underwater.gaussian_beams(absorption=) AttributeError para un valor que no es texto ni un VolumeAbsorption TypeError
filters.FilterPeriodicVerification.clause() KeyError para cualquier nombre que no se hubiera medido ValueError para un texto que no nombra ninguna de las cinco cláusulas, TypeError para un valor que no es texto; KeyError para una cláusula que no se midió
simulation.FDTD2D(absorbing_sides=, edge_impedance=), simulation.ElasticFDTD2D(absorbing_sides=, free_sides=) ValueError para cualquier lado que no conociera, fuera texto o no, con un mensaje que listaba los lados desconocidos ValueError para un texto que no es un lado, TypeError para un lado que no es texto, con el mensaje que lanza toda opción ('free_sides' must be one of ('left', 'right', 'top', 'bottom'); got 'north'.)
simulation.FDTD2D.add_plane_wave(direction=), simulation.ElasticFDTD2D.collocated(field), simulation.FDTDResult.plot(kind=), simulation.ElasticFDTDResult.plot(kind=) ValueError para cualquier valor que no conociera, fuera texto o no ValueError para un texto que no ofrece, TypeError para un valor que no es texto
simulation.FDTD2D(edge_impedance=) con una impedancia que no es un número real un booleano, solo o entre los números de un perfil, se ejecutaba como una impedancia de 1 Pa s/m, None lanzaba ValueError como una impedancia que no es finita, un texto ValueError desde la conversión a float TypeError

Cada clave de un diccionario y cada elemento de una secuencia se comprueba uno a uno: environment.assess_activity ignoraba un periodo que no conocía junto a otro que sí, y ahora lanza ValueError por él; una clave de environment.pleasantness_eventfulness que no es texto lanzaba ValueError y ahora lanza TypeError; las comprobaciones del campo sonoro de ISO 8253-2, ISO 4869-1 e ISO 4869-3 tropezaban con esa clave con un TypeError ajeno, al ordenar, y ahora nombran el parámetro; las claves de los límites de decaimiento de la vía de referencia y de la geometry del dibujo de un silenciador lanzan TypeError cuando no son texto; una clave de la section de un conducto que noise_control.duct_path no admite lanzaba el TypeError de un argumento por nombre desconocido y ahora lanza ValueError; y los balances de incertidumbre de la comparación, de la reciprocidad y de las correcciones de campo libre conservan su mensaje para un componente desconocido y lanzan TypeError para una clave que no es texto. Doce .plot() de los resultados de protectores auditivos, de reducción activa de ruido, de atenuación en oído real y de baja frecuencia de ISO 15186-3, y building.SoundReductionResult.report, aceptaban cualquier language y ahora rechazan el que no ofrecen, como el resto de los gráficos. Quien indexa con tipos una tabla publicada con un str libre (una variable str en room.TABLE_A1 o en hearing.EARPHONES) necesita ahora el Literal por el que está indexada; los valores no cambian.

El grosor de la esponja de simulation.FDTDBoundaries y simulation.ElasticBoundaries se guarda como el número entero de celdas que nombra y se comprueba al construir el registro: un valor que no es un número lanza TypeError y una fracción ValueError, cuando antes se guardaba tal cual y solo lo leía una ejecución con un lado absorbente (FDTDBoundaries(sides="rigid", absorbing_layer_cells=2.5) se construía y se ejecutaba). La shape que se da a simulation.FDTD2D, simulation.ElasticFDTD2D, simulation.FDTDRun o simulation.ElasticRun se lee siempre que se da: una ejecución la guarda como un par de enteros, desde cualquier secuencia de los dos recuentos (también una lista o un range) o un array de enteros de una dimensión, cuando antes solo admitía una tupla o una lista, una mal formada se rechaza aunque acompañe a un mapa, y una que nombra una malla distinta de la del mapa lanza ValueError (shape (4, 8) does not match the c map, whose shape is (8, 8)), cuando antes un motor ignoraba la shape que acompañaba a un mapa y una ejecución la guardaba tal cual. simulation.ElasticFDTD2D.from_regions lee su shape del mismo modo: un tercer recuento lanza ValueError y un texto TypeError, cuando antes el tercer recuento se descartaba. Un entero de numpy se admite dondequiera que estos registros y los motores admiten un recuento, y listas anidadas dondequiera que admiten un mapa. Una simulation.ContourProbe construida a mano, ContourProbe(engine, ix0, ix1, iy0, iy1, frequencies), se une a su motor y muestrea desde el paso siguiente, como la que devuelve FDTD2D.add_contour_probe; antes nunca muestreaba, y su phasors se negaba por falta de muestras. Cualquier cosa que no sea un FDTD2D como su engine lanza TypeError nombrando engine, donde un ElasticFDTD2D, None o cualquier otro objeto fallaban con un AttributeError que nombraba un atributo privado o el campo de presión.

Un registro que construye quien llama guarda lo que dicen sus campos

Sección titulada «Un registro que construye quien llama guarda lo que dicen sus campos»

Antes de 4.0 un registro guardaba una lista, una tupla o un array de otro tipo tal como se le daba, aunque su campo dijera que guardaba un array o una tupla: environment.WavelengthSpectrum(levels=[...]) guardaba la lista, de modo que spectrum.levels * 2 repetía la lista en lugar de doblar los niveles, y el registro congelado guardaba una lista a la que cualquiera podía seguir añadiendo elementos. En 4.0 un registro que construye quien llama convierte lo que recibe y guarda lo que dice su campo: un campo de array guarda un array de solo lectura de su tipo, un campo de tupla una tupla y un par un par de números, y un único número donde un valor por banda puede serlo sigue siendo el número que era. El código que añadía elementos a una lista entregada a un registro, o que volvía a leer un campo esperando la lista que dio, lee ahora el array: record.levels.tolist() devuelve la lista. Un comprobador de tipos lee el constructor que cada uno de estos registros declara para él, de modo que una lista pasa la comprobación donde el registro la convierte.

Registro Antes de 4.0 4.0
aircraft.ANPNPDCurves(powers=, distances_m=, levels=) guardaba una lista tal cual arrays float64 de solo lectura
aircraft.FlightSegmentState(ground_roll=, landing_roll=, bank=) guardaba una lista tal cual arrays de solo lectura, las máscaras bool y el alabeo float64
aircraft.FlightConditionInterpolation(triangles=) guardaba una lista de filas tal cual un array de enteros de solo lectura
aircraft.PerformanceAircraft(jet_coefficients=, propeller_coefficients=, aerodynamic_coefficients=) guardaba los diccionarios tal cual, también los de la propia base de datos, de modo que una tabla se podía editar después de comprobar el avión copias de solo lectura (dict(aircraft.jet_coefficients) devuelve una que editar)
aircraft.RotorcraftGround(ground_elevation=, flow_resistivity=, terrain=) guardaba una lista tal cual; un modelo de elevación de más o menos de tres ejes se rechazaba cuando un evento lo leía un valor por receptor como array float64 de solo lectura y el modelo de elevación como sus tres ejes, cada uno un array float64 de solo lectura; un modelo de elevación de más o menos de tres ejes se rechaza con ValueError al construirse; un número o una letra de clase tal cual; un texto entre los números de cualquiera de ellos se rechaza con TypeError, y una elevación del terreno que no es finita con ValueError, al construirse
aircraft.RotorcraftHemisphere(frequencies=, azimuth_deg=, polar_deg=, levels=) guardaba una lista tal cual arrays float64 de solo lectura
aircraft.RotorcraftTrackState(airspeed=, path_angle_deg=, heading=, bank_angle_deg=) guardaba una lista tal cual una secuencia como array float64 de solo lectura; un número tal cual
building.BandPath(values=) guardaba una lista tal cual un array float64 de solo lectura
building.FacadeElement(r=, dn_e=, insertion_loss=) guardaba una lista tal cual un valor por banda como array float64 de solo lectura; un número tal cual
building.LowFrequencyProcedure(corner_levels=) guardaba la lista tal cual un array float64 de solo lectura
electroacoustics.LoudspeakerDirectivity(polar=), electroacoustics.MicrophoneDirectivity(polar=), electroacoustics.MicrophoneNoise(spectrum=), electroacoustics.MicrophoneOverload(distortion=) guardaba el par tal cual, también una lista; lo que no fuera un par fallaba al leerse una tupla de dos arrays float64 de solo lectura; TypeError para un número o un texto, o para un texto o un valor complejo entre los números de un miembro, y ValueError para más o menos de dos miembros, al construirse
electroacoustics.LoudspeakerRatings(frequency_range=) guardaba el par tal cual y lo comprobaba al leerse un par (low, high) de floats, comprobado al construirse como los demás pares de frecuencias (TypeError, ValueError)
emission.RoomEnvironment(absorption_area=, reverberation_time=, mean_absorption_coefficient=) guardaba una lista tal cual un valor por banda como array float64 de solo lectura; un número tal cual
environment.AtmosphericAttenuation(frequencies, attenuation_db_per_m, ...) guardaba una lista tal cual arrays float64 de solo lectura
environment.WavelengthSpectrum(wavelengths_mm=, levels=), environment.RailSourceSpectra(source_a=, source_b=) guardaba una lista tal cual arrays float64 de solo lectura
environment.RollingStock(wheel_transfer=, superstructure_transfer=), environment.RailwayTrack(track_transfer=, bridge_transfer=) guardaba una lista o una tupla tal cual arrays float64 de solo lectura
environment.RoadEmissionCoefficients(studded_a=, studded_b=) guardaba una lista o un array tal cual una tupla de floats; TypeError para un número, un texto o un miembro que no es un número
environment.RoadSurfaceCoefficients(speed_range_kmh=, alpha=, beta=) guardaba el par y los dos diccionarios tal cual, de modo que las tablas se podían editar después de construir la fila un par de floats (TypeError para un número, un texto o un miembro que no es un número, ValueError para más o menos de dos) y dos mapeos de solo lectura
hearing.Task(samples=, duration_observations_hours=, duration_range_hours=) guardaba una lista o un array tal cual tuplas de floats, el intervalo un par; TypeError para un número o un texto dado como observaciones o como intervalo, ValueError para un intervalo de más o menos de dos valores
io.Signal(channel_labels=) guardaba una lista tal cual; un texto de tantas letras como canales nombraba un canal por letra una tupla; TypeError para un único texto
materials.FiberResistivityFit(bulk_density_range_kg_m3=) guardaba una lista tal cual un par de floats; TypeError para un número o un texto, ValueError para más o menos de dos valores
materials.MetadiffuserWell(resonators=) guardaba una lista tal cual una tupla
materials.TransferMatrix(t11, t12, t21, t22, frequencies=) guardaba cada elemento tal cual: un complex, una lista o un array real arrays complex128 de solo lectura: un elemento escalar es un array de dimensión cero, ya no es un complex ni es hashable (complex(m.t11) o m.t11.item() devuelve el número), y un elemento real tiene parte imaginaria nula; frequencies un array float64 de solo lectura
room.ImpulseResponseResult(ir=) guardaba una lista tal cual un array float64 de solo lectura
vibration.MultipleShockResult(peaks=, risk_thresholds=) guardaba una lista tal cual los picos como array float64 de solo lectura y los umbrales como tupla de tres floats; TypeError para un número o un texto y ValueError para más o menos de tres umbrales
vibration.TransferStiffnessResult(frequencies=, transfer_stiffness=, transmissibility=) guardaba una lista tal cual arrays de solo lectura, las frecuencias float64, la rigidez y la transmisibilidad complex128 (un valor real con parte imaginaria nula)

Cuatro resultados que guardaban un dict editable guardan en su lugar un mapeo de solo lectura, como las tablas publicadas, y asignar en uno de ellos lanza TypeError: building.FacadePredictionResult.element_r, environment.RailwayEmissionResult.components, noise_control.ReactiveSilencerResult.geometry y psychoacoustics.MooreGlasbergTimeVaryingLoudness.percentiles. El código que editaba uno lo copia antes, con dict(result.element_r). Las frecuencias centrales y las formas de onda por banda del filters.OctaveFilterResult que devuelven filters.octave_filter y OctaveFilterBank.filter son tuplas donde eran listas, listas a las que quien llama aún podía añadir elementos: result.frequencies.index(1000.0) y la indexación se leen como antes, y list(result.frequencies) devuelve una lista que editar. Un intervalo o una serie de números dados como un texto ("12") se rechazan con un TypeError que nombra el campo, se lea como se lea el texto. Un registro que vuelve de pickle o de copy.deepcopy guarda sus arrays de solo lectura, como los guardaba al salir, donde antes volvían modificables: np.array(record.levels) devuelve una copia en la que escribir.

from phonometry import environment, materials
spectrum = environment.WavelengthSpectrum(wavelengths_mm=[2000.0, 1600.0], levels=[5.0, 4.0])
matrix = materials.TransferMatrix(1.0, 0.0, 0.0, 1.0)
print(type(spectrum.levels).__name__, spectrum.levels.flags.writeable, spectrum.levels.tolist())
print(matrix.t11.shape, matrix.t11.dtype, complex(matrix.t11))
# ndarray False [5.0, 4.0]
# () complex128 (1+0j)

Un lector rechaza un nombre que no guarda un fichero regular

Sección titulada «Un lector rechaza un nombre que no guarda un fichero regular»

Un nombre que se le pasa a un lector puede guardar algo que no es un fichero. Una tubería con nombre en la que nadie escribe dejaba io.read esperando en su primera apertura a un escritor que no llegaba nunca, y lo mismo las tablas de una exportación ANP; un enlace a /dev/zero mantenía una lectura sin fin, y un directorio lanzaba lo que lanzara su primera apertura. En la 4.0 cada lector mira el nombre antes de abrirlo y lanza un ValueError que nombra el fichero y lo que guarda. Una llamada que capturaba OSError para un directorio captura ahora ValueError; un nombre sin nada detrás sigue lanzando FileNotFoundError, y un enlace a un fichero regular se sigue leyendo.

Se pasa 3.3.0 o 4.0.0rc1 4.0
una tubería con nombre a io.read, io.info, io.read_blocks o como origen de io.convert la llamada esperaba en la apertura a un escritor ValueError: "<ruta>: is a named pipe (FIFO), and audio is read only from a regular file"
un directorio a esas cuatro IsADirectoryError (PermissionError en Windows) ValueError, "... is a directory, ..."
un dispositivo a esas cuatro (/dev/zero, o un enlace a él) ValueError: no es un fichero de audio reconocido ValueError, "... is a character device, ..."
un directorio a aircraft.load_anp_database que guarda una tubería, un dispositivo o un directorio con el nombre de una de sus tablas la llamada esperaba, leía sin fin o lanzaba IsADirectoryError ValueError, "ANP table <ruta>: is ..., and an ANP table is read only from a regular file"; un fichero cuyo nombre no casa con ninguna clave de tabla ya no se abre
una tabla ANP de más de 32 MiB se leía entera ValueError, antes de leer un byte
una celda ANP con nan, inf, -Infinity o 1e999, una cabecera como L_infft, o una celda que no guarda ningún número una celda no finita se tomaba tal cual y salía como NaN en cada nivel de evento; una celda sin número lanzaba el ValueError de Python, que no nombraba ni la tabla ni la línea ValueError que nombra la tabla, la línea y la columna
una tabla ANP que no es UTF-8 UnicodeDecodeError, sin nombrar el fichero ValueError que nombra la tabla y el byte
un recuento ANP (una longitud de etapa, un número de punto o de paso, un número de motores) de 1.5, o un número de motores en blanco se tomaba como 1, y el número de motores en blanco como 0; una longitud de etapa de los pesos o de los pasos de despegue, escrita así o nan, lanzaba el ValueError de un argumento stage_length, que no nombraba ninguna tabla ValueError que nombra la tabla, la línea y la columna
import tempfile
from pathlib import Path
from phonometry import io
with tempfile.TemporaryDirectory() as folder:
try:
io.read(Path(folder))
except ValueError as refusal:
print(str(refusal).split(": ", 1)[1])
# is a directory, and audio is read only from a regular file

Una ruta de otra biblioteca llega al fichero que nombra

Sección titulada «Una ruta de otra biblioteca llega al fichero que nombra»

io.write, io.read, io.info, io.read_blocks e io.convert pasaban una ruta a SciPy y a python-soundfile como str(path). Para un str o un pathlib.Path eso es la ruta; para cualquier otro os.PathLike, un os.DirEntry o una clase de ruta de otra biblioteca, es el repr del objeto. En la 4.0 cada una toma la ruta que nombra el objeto, los mensajes la escriben, y las anotaciones dicen str | os.PathLike[str], como ya decían las de los escritores de vídeo. Un str o un pathlib.Path se comportan como antes.

Se pasa 4.0.0rc1 4.0
un os.PathLike que no es ni un str ni un pathlib.Path, a io.write (un WAV de 16 o 32 bits, un WAV en coma flotante, un FLAC, o bext="loudness") el fichero iba a un nombre hecho con el repr del objeto, <... object at 0x...>, en el directorio de trabajo el fichero que nombra el objeto
lo mismo a io.read, o como origen de io.convert, y un FLAC a io.info o io.read_blocks FileNotFoundError con el repr, o el LibsndfileError de python-soundfile para un FLAC se lee el fichero que nombra el objeto
lo mismo a io.info AudioFileInfo.path guardaba el repr AudioFileInfo.path es la ruta

Un escritor pone su fichero en el nombre sólo cuando está entero

Sección titulada «Un escritor pone su fichero en el nombre sólo cuando está entero»

io.write, el destino de io.convert, cada .report() y la gráfica de respuesta de un banco de filtros escribían directamente en el nombre que recibían. Un error o una interrupción a medias dejaban ahí un fichero empezado, encima de la grabación o de la ficha de una ejecución anterior, y una ficha demasiado larga para su página se construía en el nombre y se borraba después, y con ella la ficha anterior. En la 4.0, si en el nombre no hay nada o hay un fichero regular, cada uno escribe un fichero oculto a su lado y lo renombra sobre el nombre cuando está entero, con los bits de permiso del fichero antiguo, y solo su propietario puede leerlo mientras se escribe sobre un fichero. El fichero nuevo es del escritor: toma su propietario y su grupo, y no conserva ni las listas de control de acceso ni los atributos extendidos del fichero antiguo. Su nombre oculto se recorta a lo que admite el directorio, así que un nombre tan largo como el directorio permite se escribe como cualquier otro. Un enlace, una tubería, un dispositivo o un directorio en el nombre se abren ahí como antes, así que una grabación que se envía a una tubería a propósito sigue entrando en la tubería.

Se pasa 3.3.0 o 4.0.0rc1 4.0
una escritura, una conversión, una ficha o una gráfica de respuesta detenidas a medias por un error o una interrupción un fichero empezado en el nombre, en lugar de lo que había el nombre como estaba, y nada a su lado
una ficha demasiado larga para su página, en el nombre de una ficha anterior ValueError, y la ficha anterior borrada ValueError, y la ficha anterior intacta
un nombre cuyo fichero tiene un enlace duro en otro sitio los bytes nuevos en el fichero, y por tanto bajo los dos nombres el fichero nuevo en el nombre; el otro nombre conserva los bytes antiguos
un fichero con permiso de escritura en un directorio que no admite ficheros nuevos se escribía en su sitio el PermissionError del fichero de al lado, y el fichero antiguo intacto

Los patrones lobulados de un ventilador entubado son velocidades de giro, no líneas

Sección titulada «Los patrones lobulados de un ventilador entubado son velocidades de giro, no líneas»

vibration.blade_pass_frequencies(..., n_vanes=...) devolvía los patrones de interacción rotativos de un ventilador entubado entre sus líneas, como entradas FaultLine de la familia "blade" llamadas lobe n=1 m=2, con la velocidad de la Ec. (8.17) como frecuencia de la línea en hercios. Norton sitúa el ruido de esos patrones en el armónico de paso de pala del que salen, así que un espectro no tiene línea en esas velocidades, y .plot() y combine_fault_lines la marcaban igualmente. El número de lóbulos perdía además su signo, que es el sentido en que gira el patrón.

En la 4.0 la función devuelve un BladePassResult, un FaultFrequencyResult cuyas líneas son solo los tonos del eje y de paso de pala, y guarda aparte los patrones en lobe_patterns, un LobePattern por armónico de pala y orden de álabe con su signo: harmonic, vane_order, n_lobes (negativo para un patrón que gira contra el rotor) y speed_rpm, la velocidad de la Ec. (8.17) en r/min, como la imprime Norton. within conserva los patrones; combine_fault_lines junta solo las líneas.

4.0.0rc1 4.0
res["lobe n=N m=M"], la velocidad sin signo en hercios del patrón del armónico de pala N con M lóbulos en cualquier sentido abs(next(p for p in res.lobe_patterns if p.harmonic == N and abs(p.n_lobes) == M).speed_rpm) / 60
res.names con entradas lobe n=… m=… res.names solo con las líneas del eje y de paso de pala; los patrones en res.lobe_patterns
un patrón con nombrado por , con velocidad positiva n_lobes y speed_rpm negativos, y un patrón de a su lado conservado como otro
las velocidades marcadas como líneas por .plot() y llevadas por combine_fault_lines líneas solo en el eje y en el paso de pala
from phonometry import vibration
res = vibration.blade_pass_frequencies(3500.0, 6, n_harmonics=1, n_vanes=4)
print(res.names)
print([(p.n_lobes, p.speed_rpm) for p in res.lobe_patterns])
# ('shaft', 'BPF')
# [(2, 10500.0), (10, 2100.0)]

Todo lo demás se movió. Estos setenta y ocho no existen en ningún módulo público:

Ya no está Qué escribir en su lugar
octavefilter, getansifrequencies, normalizedfreq filters.octave_filter, filters.nominal_frequencies, filters.normalized_frequencies. Eran las grafías originales de PyOctaveBand, renombradas en la 3.1 y conservadas como alias hasta la 4.0
calculate_sensitivity metrology.sensitivity, el mismo renombrado de la 3.1
filter_class_compliance filters.verify_filter_class
air_density_iso, speed_of_sound_iso materials.air_density_iso10534, materials.speed_of_sound_iso10534, y lee el aviso de los kelvin de más arriba
speed_of_sound materials.speed_of_sound_iso17497(temperature_c=...), la misma fórmula de la ISO 17497-1 y el mismo número. No fluids.air(...).speed_of_sound, que calcula aire húmedo con otro modelo: 343,99 m/s frente a 343,20 m/s a 20 °C, como dice la sección del arreglo evidente
depth_to_pressure fluids.depth_to_gauge_pressure_mpa(depth_m=...), que devuelve el mismo número, o fluids.depth_to_absolute_pressure_pa para la absoluta. Las dos son keyword-only y las dos toman un latitude_deg opcional
TransmissionLossResult PropagationLossResult, con .tl renombrado a .pl
partial_exposure vibration.daily_exposure, llamada con el valor y la duración de una sola operación. partial_exposure era un segundo nombre de la misma función, y el número no se mueve
insitu_reflection_factor, insitu_absorption_from_reflection, insitu_absorption_coefficient, insitu_absorption_spectrum, InsituAbsorptionResult materials.in_situ_reflection_factor, materials.in_situ_absorption_from_reflection, materials.in_situ_absorption_coefficient, materials.in_situ_absorption_spectrum, materials.InSituAbsorptionResult: in situ se escribe in_situ en todas partes, como ya lo escribían los nombres in situ de building, emission y noise_control
DEFAULT_SPEED_OF_SOUND materials.ISO13472_SPEED_OF_SOUND_M_S, los 340 m/s del Anexo A de la ISO 13472-1. Los 343 m/s que toman por omisión los módulos de salas son privados ahora; pasa speed_of_sound= para decir cuál quieres
OCTAVE_BANDS, THIRD_OCTAVE_BANDS materials.RATING_OCTAVE_BANDS_HZ, materials.RATING_THIRD_OCTAVE_BANDS_HZ, las bandas de la clasificación de la ISO 11654
BASE_PLATE_BANDS materials.BASE_PLATE_BANDS_HZ
DEFAULT_POLAR_ANGLES materials.DEFAULT_POLAR_ANGLES_DEG
DEFAULT_MIC_HEIGHT, DEFAULT_SOURCE_HEIGHT materials.DEFAULT_MICROPHONE_HEIGHT_M, materials.DEFAULT_SOURCE_HEIGHT_M
PART1_FREQUENCY_RANGE, SPOT_FREQUENCY_RANGE, SPOT_NARROW_BAND_RANGE materials.PART1_FREQUENCY_RANGE_HZ, materials.SPOT_FREQUENCY_RANGE_HZ, materials.SPOT_NARROW_BAND_RANGE_HZ
REFERENCE_ACCELERATION vibration.ACCELERATION_LEVEL_REFERENCE_M_S2, el 1 µm/s² de la ISO 1683. vibration.REFERENCE_ACCELERATION_M_S2 es otra cosa, las condiciones de referencia de la Tabla 1 de la ISO 8041-1
REFERENCE_AREA building.REFERENCE_AREA_M2
REFERENCE_VELOCITY emission.REFERENCE_VELOCITY_M_S
DEFAULT_FREQUENCIES environment.DEFAULT_FREQUENCIES_HZ
NOY_BANDS aircraft.NOY_BANDS_HZ
UNDERWATER_REFERENCE_PRESSURE underwater.UNDERWATER_REFERENCE_PRESSURE_PA
UNDERWATER_REFERENCE_EXPOSURE underwater.UNDERWATER_REFERENCE_EXPOSURE_PA2_S, el 1 µPa² s de la ISO 1683 en Pa² s
NORMALIZED_IMPEDANCE emission.NORMALIZED_IMPEDANCE_PA_S_M, los 411 Pa s/m de la ISO/TS 7849
NO_TONE_AUDIBILITY psychoacoustics.NO_TONE_AUDIBILITY_DB
REFERENCE_STIFFNESS vibration.REFERENCE_STIFFNESS_N_M
HAV_EAV_A8, HAV_ELV_A8, WBV_EAV_A8, WBV_ELV_A8 vibration.HAV_EAV_A8_M_S2, vibration.HAV_ELV_A8_M_S2, vibration.WBV_EAV_A8_M_S2, vibration.WBV_ELV_A8_M_S2, los valores de A(8) de la Directiva 2002/44/CE. WBV_EAV_VDV y WBV_ELV_VDV conservan su nombre, porque un valor de dosis de vibración tiene una sola unidad, m/s^1,75
combine_uncertainties metrology.combined_standard_uncertainty, la única raíz de la suma de cuadrados, que toma las contribuciones como una sola secuencia: combine_uncertainties(3.0, 4.0) es combined_standard_uncertainty([3.0, 4.0])
combine_uncertainty metrology.uncertainty_propagation, la propagación GUM a través de un modelo, con los mismos model, quantities y correlation
expanded_uncertainty building.insulation_expanded_uncertainty(u, coverage, one_sided=...), la función de la ISO 12999-1 a la que remitía el nombre de primer nivel de la 3.3.0, con el mismo número: expanded_uncertainty(1.2) e insulation_expanded_uncertainty(1.2) dan los dos 2,352 dB. La incertidumbre expandida GUM de un resultado propagado es result.expanded(coverage). environmental.expanded_uncertainty, la función de la ISO 1996-2 con el mismo nombre, es environment.environmental_expanded_uncertainty(u, coverage=...), 2,4 dB para el mismo 1,2 dB
combine_linings, combine_subareas, combine_partial_exposures, combine_age_and_noise building.combined_lining_improvement, building.subarea_intensity_level, vibration.combined_daily_exposure, hearing.age_and_noise_threshold: un cálculo se nombra por lo que devuelve
air_attenuation_m environment.air_power_attenuation_per_m. La m que devuelve es el coeficiente de atenuación de potencia de la ISO 354, en 1/m, no una longitud
attenuation_from_alpha, air_attenuation_coefficient materials.power_attenuation_from_alpha, la única conversión que hacen la ISO 354 y la ISO 17497-1. Su argumento es attenuation_db_per_m, donde las dos funciones antiguas lo llamaban alpha y pressure_attenuation_db_per_m. Rechaza un alfa NaN o infinito, que attenuation_from_alpha dejaba pasar
HtlanResult, NiptsResult hearing.HTLANResult, hearing.NIPTSResult: un acrónimo se escribe en mayúsculas, como en HMLRatingResult
AnpAircraft, AnpDatabase, AnpNpdCurves, AnpProfile, NpdLevelResult aircraft.ANPAircraft, aircraft.ANPDatabase, aircraft.ANPNPDCurves, aircraft.ANPProfile, aircraft.NPDLevelResult; el número de motores es ANPAircraft.n_engines
HvacSpectrumResult noise_control.HVACSpectrumResult
mic_calibration_factor, apply_mic_calibration materials.microphone_calibration_factor, materials.apply_microphone_calibration
lab_airborne_insulation, lab_impact_insulation, LabAirborneInsulationResult, LabImpactInsulationResult, LabInsulationWarning building.laboratory_airborne_insulation, building.laboratory_impact_insulation, building.LaboratoryAirborneInsulationResult, building.LaboratoryImpactInsulationResult, building.LaboratoryInsulationWarning
EnclosureResult noise_control.EnclosureInsertionLossResult, lo que devuelve enclosure_insertion_loss, junto a EnclosureInsulationResult
maximum_repeatability_standard_deviation, minimum_cumulative_duration_hours, minimum_phase building.max_repeatability_standard_deviation, hearing.min_cumulative_duration_hours, signals.min_phase: max y min en todo nombre público
rigid_mass_calibration_check vibration.verify_rigid_mass_calibration, con los mismos argumentos y el mismo RigidMassCalibrationResult: juzga una cadena de medida, así que su verbo es verify_
satisfies_lower_requirement, satisfies_upper_requirement building.assess_requirement_conformity(rating, expanded_uncertainty_db, required_rating, bound="minimum") o bound="maximum". El booleano es su .passes, junto al .margin_db del que se lee, y las dos fórmulas siguen siendo estrictas
strong_coupling_satisfied building.check_strong_coupling, con los mismos argumentos. El array booleano es su .holds, y .passes es todas las bandas
tonal_seeking_survey environment.assess_tonal_survey(levels, frequencies=frequencies). El array booleano es su .prominent, junto a los .min_level_differences y .level_differences de los que se lee
air_density_astm, speed_of_sound_astm materials.air_density_astm_e2611, materials.speed_of_sound_astm_e2611, junto a air_density_iso10534: la designación de una norma en un nombre se escribe de una sola forma
sae_band_attenuation aircraft.band_attenuation_arp5534, el documento que sigue
itu_r_468_weighting electroacoustics.weighting_bs468

Casi todos los números. Cada renombrado de esta página devuelve lo que devolvía su predecesor, salvo donde esta sección diga otra cosa, y si cualquier otro resultado se mueve después de que termines de actualizar, eso es un defecto y merece la pena avisar. Los números que sí se movieron están abajo. Cada uno se movió porque la 3.3.0 no coincidía con el documento que sigue, o porque cambió un valor por defecto.

verify_filter_class califica todos los requisitos de IEC 61260-1 a la frecuencia de entrada del banco, no solo la máscara de la Tabla 1, y una banda de un banco diezmado se mueve hasta 0,07 dB con ruido blanco: la sección sobre las clases de filtro de más arriba explica cómo.

Lo que se movió 3.3.0 4.0
Todas las curvas, A, B, C, D, G y AU, a través de WeightingFilter.filter y de filters.weighting_filter, que ahora se diseñan a la frecuencia de entrada en vez de sobremuestreadas, y por tanto todo nivel que pondera una señal con ellas, signals.laeq entre ellos A a 48 kHz: −2,60 dB, −7,03 dB y −10,15 dB en las filas de 10, 16 y 20 kHz de la Tabla 3 de IEC 61672-1; a 16 kHz, A −13,1 dB y C −16,7 dB en la fila de 8 kHz; a 32 kHz, B −23,9 dB, D −17,1 dB y AU −35,9 dB a 16 kHz −2,49 dB, −6,60 dB y −9,32 dB, los objetivos de diseño con 0,02 dB de diferencia como mucho; −1,11 dB y −3,01 dB en la fila de 8 kHz; B −8,42 dB, D −0,69 dB y AU −19,61 dB, de nuevo los objetivos de diseño
WeightingFilter(..., stateful=True), que en la 3.3.0 ejecutaba A con el diseño bilineal simple y G con secciones diseñadas para una frecuencia sobremuestreada, las dos a la frecuencia de entrada, y ahora ejecuta el diseño preciso A a 48 kHz: −7,05 dB en la fila de 12,5 kHz; G en su propia referencia de 10 Hz: −26,3 dB a 8 kHz y −36,3 dB a 1 kHz −4,32 dB, el objetivo de diseño; 0 dB a cualquier frecuencia de muestreo
verify_weighting_class calificaba las secciones diseñadas, y daba la clase 1 a una ponderación A a 16 kHz que perdía 12 dB en la fila de 8 kHz califica el camino que recorre una señal a través de WeightingFilter.filter
itu_r_468_weighting, ahora electroacoustics.weighting_bs468 la Tabla 1 de UIT-R BS.468-4 interpolada entre sus filas: 4,45 dB a 11,06 kHz la curva de la red que imprime la Recomendación: 5,06 dB ahí, y a unos 0,05 dB como mucho de la Tabla 1 en sus filas
sae_band_attenuation, ahora aircraft.band_attenuation_arp5534 la presión de vapor de saturación de la ISO 9613-1 la que imprime SAE ARP 5534: unos 0,01 dB menos en 1 km a 8 kHz y 10 kHz
extended_tube_chamber con una prolongación de entrada o de salida el tramo recto entre las dos ramas laterales tomado sobre toda la longitud L de la cámara sobre L − L_a − L_b, que reproduce la Figura 8.20 de Bies: para L = 0,5 m, una relación de áreas m = 16 y prolongaciones de 0,125 m y 0,25 m, 22,7 dB a 200 Hz donde daba 0,6 dB
underwater.ray_trace y environment.atmospheric_ray_paths en una reflexión un paso entero dado a través de la frontera y plegado de vuelta un subpaso que acaba en la frontera, así que un rayo que rebota llega a otro sitio: un rayo de un canal de 100 m acaba a 5 km a 9,4 m de profundidad, donde acababa a 0,3 m
room.open_plan_metrics cuando el STI nunca baja hasta el umbral una distancia de distracción o de privacidad de 10¹⁵ m o más NaN
effective_kappa y thermal_boundary_layer_thickness con su aire por defecto los cinco valores que imprime el Anexo A.3 de la ISO 9053-2 el aire de IEC 61094-2 en el mismo estado, que mueve la corrección en su quinta cifra, como dice la sección sobre fluid=
un valor que cae justo en un límite que imprime una norma se juzgaba por los últimos bits de su valor en coma flotante se asienta antes a nueve decimales, igual en cualquier máquina

El propio módulo de diseño de ponderaciones es nuevo en 4.0.0rc1, así que tres de sus cambios se miden contra la versión candidata y no contra 3.3.0:

Lo que se movió 4.0.0rc1 4.0
WeightingFilter.sos en macOS y Windows, con glibc en x86-64 sin FMA, y en Linux en seis de los diseños comprobados y a frecuencias con las que no se comprueba la biblioteca la biblioteca C de cada plataforma redondeaba a su manera las exponenciales, potencias, logaritmos, sin, tan y arcotangentes del diseño, y numpy compilado con clang, en macOS y Windows, fusionaba en multiply-adds los productos complejos de la transformada bilineal, así que la ponderación A a 48 kHz tenía un digest por plataforma, entre ellos 43f786ffab5c4dd4 con glibc sin FMA en el diseño no queda ninguna rutina de la biblioteca C ni ningún producto complejo de numpy: toda plataforma diseña la ponderación A a 48 kHz con 991833ff389afe91, y cada una de las demás curvas con unos mismos bytes también, porque las raíces y las secciones de la cascada son también aritmética propia del paquete; en Linux la arcotangente correctamente redondeada mueve en sus últimos bits las ponderaciones A y C a 44,1 y 88,2 kHz, la D a 88,2 kHz y la G a 1,5 kHz (la A a 44,1 kHz pasa de 74d1e53f498988c5 a dbea4b7fc4ad972b), y de 1 399 307 diseños (frecuencia, curva) a frecuencias enteras entre 100 Hz y 200 kHz, 5 864 encuentran un sin o una tan que glibc redondea al otro lado y 45 526 leen un nivel objetivo que su arcotangente cambia, y pueden moverse, entre las frecuencias habituales 50 kHz para A, B, C y D, 100 kHz para AU y 176,4 kHz para A, B y C
WeightingFilter(fs, "468").sos a cualquier frecuencia de muestreo, y WeightingFilter(fs, "AU").sos a 100 y 200 Hz los polos del prototipo 468, de LAPACK a través de numpy.roots, y las secciones del zpk2sos de SciPy, que emparejaba polos con ceros por el módulo complejo de numpy las raíces correctamente redondeadas del polinomio exacto de la red y las secciones propias del diseño: la respuesta 468 se mueve como mucho 0,0072 dB en las diecinueve frecuencias comprobadas, de 100 Hz a 192 kHz (0,000012 dB a 48 kHz, donde el digest pasa de 08f94c9ff182cff1 a eee92dba5dcc41f7), y la AU hasta dos unidades en el último lugar de ocho coeficientes a 100 Hz y una unidad de seis a 200 Hz
WeightingFilter(fs, "B", high_accuracy=False).sos, y lo mismo para C y G el módulo complejo detrás de la ganancia, del valor absoluto complejo propio de numpy del hypot fijado: una unidad en el último lugar de la ganancia en Linux

La ficha ISO 3382 de un análisis en tercios de octava toma su tiempo de reverberación de un solo número sobre las seis bandas de 400 Hz a 1250 Hz, como imprime el apartado 9.1, donde promediaba las bandas de 500 Hz y 1 kHz. La ficha ISO 10846 de una determinación indirecta enmarca la rigidez en la línea más baja que admite la Desigualdad (2) de la ISO 10846-3, con una transmisibilidad de 0,1 o menos, donde enmarcaba la línea más baja del barrido, dentro de la zona de la resonancia. La ficha del micrófono escribe dB(468) para la ponderación UIT-R BS.468-4, que la 3.3.0 te dejaba etiquetar como CCIR. Una gráfica dibuja una banda sin lectura como ninguna barra, donde dibujaba un cero medido. Hay dos más en las secciones de arriba: installed_dynamic_stiffness por debajo de 100 kPa·s/m², y las posiciones del método de control de la ISO 3746 de emission.measurement_positions.

Para el código escrito contra la 4.0.0rc1, el contrato de Signal es el que era, ahora cumplido en dos sitios más, los bloques de read_blocks y las formas de onda dentro de cinco resultados. Cualquier otra fórmula está intacta. La 4.0 recolocó los muebles y puso la unidad en la etiqueta; salvo lo que recoge esta sección, no recalculó nada.