Upgrading from 3.3 to 4.0

4.0 is a hard break with no compatibility layer. Almost nothing was deleted: of the 885 names the root exported in 3.3.0, ten exist nowhere any more and the rest simply live at a named address instead of a flat one. So most of the work is an import sweep, and this page is mostly a map.

Read the first two sections and you can fix the imports. Read the third even if you are in a hurry, because in three places the obvious fix is the wrong one, and one of those three changes a number without raising anything.

In 3.3.0 the root re-exported the whole library, so from phonometry import laeq worked for almost every name. Today the root exports twenty-five things: the twenty-one subpackages, the three classes that belong to no single domain (Signal, ReportMetadata, PhonometryWarning) and __version__.

import phonometry

print(len(phonometry.__all__))          # 25
print("laeq" in phonometry.__all__)     # False

from phonometry.signals import laeq     # this is the new spelling

Measured across the whole surface, 872 of those 885 root names are published today by exactly one subpackage, none by two, and none needs a path deeper than phonometry.<subpackage>. Three more are still at the root, where they always were. So the swap is unambiguous: find the subpackage, import from it.

The attribute form was never removed, which is the smallest possible diff for code that reached through the root:

from phonometry import filters

_, _, _, labels = filters.nominal_frequencies(1)
print(labels)

Rather than search the reference for each one, ask the installed package:

import importlib
import pkgutil

import phonometry


def whereis(name):
    """Every public module that publishes `name`, shallowest first."""
    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

It walks the tree in about two seconds. When it returns several paths the shallowest one is the canonical import: a subpackage re-exports what its own modules publish, and that shallow path is the one the guides and the tests use. The four names the root still publishes on its own, Signal, PhonometryWarning, ReportMetadata and __version__, come back as phonometry itself. An empty list means the name is in the last section of this page.

Five of the thirty modules that changed path did not move to one new address. They were divided, and a reader who follows only the first half of the split gets an ImportError for the rest. These are worth checking one by one, and the private renderer package is listed with them because the same thing happened to it:

The other twenty-five moved whole, and the resolver above finds them without reading this table. Each of the first three was reachable by two paths in 3.3.0, the flat one and the one under its package, and both are gone.

Everything else on this page announces itself the moment you run it, and the fix is the one it looks like. These three are not that.

air_density_iso and speed_of_sound_iso documented and consumed their temperature in kelvin. Their successors take degrees Celsius, like the rest of the library. The names changed, so the import fails and you will notice, but the argument you carry over is the problem: 293.15 is a legitimate-looking number in either unit.

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 against 477.13 m/s: a 39 % error, no exception, and every absorption coefficient computed from it is wrong by a plausible-looking amount. Convert the value, do not just rename the keyword.

With the conversion applied both return exactly what they returned in 3.3.0, bit for bit.

The ISO 17497-1 helper of the same name took degrees Celsius, so no conversion is needed there. The catch is the replacement. fluids.air() uses a fuller model of the medium than the ISO 17497-1 one-liner, and at 20 °C it answers 343.99 m/s where the old helper answered 343.20 m/s. That is small, and it is not nothing if you are reproducing a measurement made with the old number. ISO 17497-1 clause 8 prints the formula if you need that clause exactly.

transmission_loss became propagation_loss, which the import catches, and the field inside the result was renamed with it. That one does not raise: a PropagationLossResult has no .tl, so the AttributeError arrives wherever you read it, which may be far from the call.

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, the number .tl used to hold

The same rename reaches underwater.sonar_equation, whose transmission_loss parameter is now propagation_loss.

Five entry points no longer take the ambient conditions as loose numbers. Renaming the keyword is not enough there, because the parameter is gone entirely:

The per-point rotorcraft overrides went the same way: bank_angle and path_angle are now RotorcraftTrackState(bank_angle_deg=..., path_angle_deg=...).

from phonometry.aircraft.airport_noise import AerodromeAtmosphere

atmosphere = AerodromeAtmosphere(temperature_c=15.0, atmospheric_pressure_kpa=101.325)
print(atmosphere.temperature_c, atmosphere.atmospheric_pressure_kpa)

Everywhere else, the ambient conditions kept their place and gained a suffix. The rule is that a public parameter naming a dimensional quantity ends in the unit the caller types, because a number is where a unit is lost and no guard can catch it by magnitude: 101.325 and 101325 are both legitimate pressures in this library.

One case is worth naming because it was a trap rather than an inconvenience. critical_angle was a field in radians on one result and a parameter in degrees on the two functions one screen below it, which is the same word for two things 57 times apart. It is critical_angle_rad on the result and critical_angle_deg on the parameters now.

transmission_loss= became propagation_loss= only in the underwater sonar and numerical-propagation results. ReactiveSilencerResult and SoundReductionResult still call theirs transmission_loss=, correctly: that is what the standards behind them call it.

The EN 29052-1 functions of materials follow the same rule, with the unit of each quantity at the end of its name:

The airflow resistivity is the one that earns the keyword. EN 29052-1 thresholds it in kPa·s/m², and every other flow resistivity in the library is in Pa·s/m², a unit a thousand times smaller, so a Pa·s/m² figure passed by position landed in the wrong branch of clause 8.2 without a word; it is written by name now. And below 100 kPa·s/m², installed_dynamic_stiffness no longer reads a missing gas term as zero: 3.3.0 returned $s_{\mathrm{t}}^{\prime }$ from installed_dynamic_stiffness(20e6, 50.0), Formula 6 with its second term dropped, and 4.0 raises and asks for $s_{\mathrm{a}}^{\prime }$.

Two rules made 37 signatures keyword-only. A condition or an option that carries a default is written by name, and every public boolean flag is keyword-only. Both exist because the call site is where the meaning is lost: air_attenuation(freqs, 20.0, 50.0, 101.325) is a temperature, a humidity and a pressure in an order nobody remembers, and bank.filter(x, True) says nothing about which of five flags was thrown.

The failure is loud, which is the point:

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

That call is worth a second look. leq never had an fs, because an energy average does not need one, so in 3.3.0 the 48000 silently bound to calibration_factor and the answer came back 93.6 dB high with no complaint. Now it is a TypeError, which is what it always should have been.

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

The public names had drifted into several spellings of the same quantity, and 4.0 keeps the one the majority already used. The rule for the quantities counted in the plural is the one most of the API followed: a field or a parameter that holds an array is frequencies, times, distances or levels, and one that holds a single value is singular. A vectorised argument that takes either a number or an array keeps its name.

times, levels = decay_curve(ir, fs) still unpacks the decay curve, in the same order. The FDTD solvers keep c and rho, which name the maps their equations are written in.

Every result’s .plot() now reads plot(ax=None, *, ...): the axes first, and every other argument by name, language included. Three did not start with the axes in 3.3.0, so plot(ax) on them handed the axes to the wrong parameter:

Six results that are newer than 3.3.0 took language by position in 4.0.0rc1: the four hearing-protector ratings and the two low-frequency intensity results. plot(ax, "es") on those is plot(ax, language="es") now, as it is everywhere else.

The five verify_* functions returned dict[str, Any] and now return a frozen dataclass, like every other result in the library. Two public wrappers that existed only to package that dictionary went with the change, since the verifier now returns the object itself.

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 is newer than 3.3.0, and in 4.0.0rc1 it returned a bare bool, which threw away the printed interval and the measured time it had judged. It now returns a RunningRmsDecayVerification that keeps both: the verdict is .passes, beside .measured_time_s, .printed_time_s, .tolerance_s and the interval as .lower_time_s and .upper_time_s. The object refuses to be read as a truth value, so an if verify_running_rms_decay(...): written against the release candidate raises TypeError instead of passing every meter.

octave_filter() and OctaveFilterBank.filter() returned two items normally and three when sigbands=True asked for the band waveforms. The length of the answer depended on a keyword, which is why the pair needed twelve @overload declarations to be typed at all, and why _, _, bands = bank.filter(...) was a line you had to count commas in.

They now return an OctaveFilterResult with named fields, like every other computation in the library.

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 is None unless the call asked for sigbands=True, and levels is None for a call made with calculate_level=False. Code that needs either one can say so with require_bands() or require_levels(), which return the value or raise naming the argument that was missing, rather than handing back a None that fails several lines later.

The result also draws itself, so the band spectrum is one call:

ax = result.plot()

A transform handed a Signal has returned a Signal since the contract was written, but five result objects still stored their waveform as a bare array next to a loose fs. They now keep the type the input arrived as:

A bare array in still gives a bare array out, so code that passes arrays does not notice. Code that passes a Signal and does arithmetic on one of these fields goes through np.asarray, as it does for any Signal, and a calibrated input comes back with calibration_factor=1.0, so the field feeds the next function in pascals without the factor being applied again.

io.read_blocks is newer than 3.3.0, and in 4.0.0rc1 it yielded bare float64 arrays. It now yields a Signal per block, carrying the rate, the calibration, the channel labels and the provenance io.read gives, and it takes the same calibration_factor= and reads the same sidecar. Two things change for a loop written against the release candidate. A block from a calibrated file reaches the filters and the level functions in pascals, so a calibration_factor applied by hand on top of it counts twice. And arithmetic on a block, or on what a filter returns for one, goes through np.asarray, as it does for any Signal.

Every table the library publishes at module level is read-only in 4.0. In 3.3.0 published tables were plain dictionaries and published arrays took in-place arithmetic, so a line such as REFERENCE_CURVE[500] = 0.9 or BAND_IMPORTANCE *= 2 changed the number for every caller that ran after it in the same process, and nothing raised. The dictionaries are now types.MappingProxyType, including the ones nested inside another table, and the arrays have their writeable flag cleared. Reading is unchanged; writing raises TypeError on a table and ValueError on an array.

Code that adjusted a published table has to copy it first:

from phonometry.materials.absorbers import REFERENCE_CURVE
from phonometry.speech.sii import BAND_IMPORTANCE

curve = dict(REFERENCE_CURVE)
curve[4000] = 1.0
weights = BAND_IMPORTANCE.copy()
weights[0] = 0.0
print(REFERENCE_CURVE[4000], curve[4000], weights[0], BAND_IMPORTANCE[0])
# 0.9 1.0 0.0 0.0083

A table with tables inside it needs each level copied, as in {area: dict(rows) for area, rows in GUIDE_VALUES.items()}. The same copy is needed before a table is pickled, deep-copied or written out as JSON, because a read-only mapping supports none of the three.

In 3.3.0 and in 4.0.0rc1 a result kept the very array it was handed whenever that array was already of the type the function reads, float64 for levels and frequencies, because np.asarray hands its argument back unchanged in that case. Changing the caller’s array afterwards, levels[0] = 0.0 or frequencies *= 2, changed a result already computed and perhaps already printed. In 4.0 every array that a function or a method of the library keeps from the arguments it was given is a copy of its own, made read-only like the published tables, and the caller’s array is left as it was. That holds for the objects that keep arrays to hand out later as well: the frequency grid of a noise_control.SilencerChain, the axes and flight paths an aircraft.AnpDatabase is built from, and the medium maps of simulation.FDTD2D and simulation.ElasticFDTD2D, whose c, rho, c_p and c_s now stay the ones the time step was computed from. A Signal keeps a copy of its own samples too, which stays writeable for processing in place, as the samples of a file read with io.read always were. A result record built by hand, by calling its class directly, makes the same copy: every public record that can hold an array copies the arrays it is handed when it is built, whoever builds it, also inside a tuple, a list or any mapping. A record held inside another one is kept whole and answers for its own arrays, and a Signal is no exception: the seven results that hand a waveform back as a Signal (filters.OctaveFilterResult, signals.EnvelopeResult, signals.ResampledSignalResult, signals.AlignedImpulseResponseResult, signals.SynchronousAverageResult, environment.DirectSoundSubtraction and underwater.PileStrikeResult) hold one of their own when the library builds them, whose samples stay writeable like any Signal’s, and hold the caller’s own when built by hand around it. Every other array a result holds refuses in-place writes, the ones it computed as well as the ones it was given, where in 3.3.0 most computed arrays took them. Writing into one now raises ValueError, so code that edited one in place has to copy it first:

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

The published catalogues of materials are new in 4.0: neither 3.3.0 nor 4.0.0rc1 had them. They changed shape once on the way to the final release, and code written against the main branch in between needs the changes below. Every row of every catalogue now shares one base, io.CatalogueRow (with io.BandedRow for a row that prints one value per band), and the same three questions have the same answer on any of them.

is_derived now answers only for what the library computes and could compute again from the row’s own cells, such as a bar speed worked out from a modulus and a density. A value the page gives in another unit is still the page’s number, and so is one it gives by reference to another of its rows, so neither is derived any more. basis_of answers with the field’s own entry, else the row’s, else an empty string, which means the source does not say how the number was obtained; the five things a source can claim are in 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

The resilient layers became catalogue rows in the same change. A ResilientLayer is an io.CatalogueRow like every other row, keyed and credited the way the others are:

Hopkins Table A3 prints $s^{\prime }$, the stiffness of the installed layer as the book’s own list of symbols defines it, so its fifteen rows still hold dynamic_stiffness_n_m3 and return the natural frequencies they returned before. Four of them hold a density the page prints once for their block and leaves blank on their own line, and layer.carried["density_kg_m3"] now names the row that prints it; the density is the same.

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

Every catalogue row is checked in its constructor, whether the library builds it from a packaged table or a caller builds it by hand, and a cell nothing downstream could read raises io.CatalogueError, naming the row and the field. Code written against the main branch in between that relied on any of these being accepted has to change:

Every other packaged row already met the contract, so those six porosities are the only published cells that change, and every published porous row with both moduli prints its loss factor.

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

verify_filter_class graded the Table 1 mask alone. For the 2014 edition it now also grades the effective bandwidth deviation of 5.12 and the summation of output signals of 5.16, computed as IEC 61260-2:2016 computes them, and a band’s class and the bank’s overall_class are the strictest class met on all three. For the 1995 edition it grades the filter integrated response of 4.5.3 and the summation of output signals of 4.9 beside Table 1, as that edition’s clause 5 tests them. In both editions every band is graded at the bank’s input rate up to half of it, so a decimated band is graded on the alias images its decimation folds onto it, and the bank’s decimator keeps them more than 125 dB down.

The octave and one-third-octave banks keep class 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

A verdict used to carry the limit it was judged against as a constructor field. In 3.3.0 three did: ToneAssessment.criterion_db, ExposureAssessment.action_value and limit_value, and RigidMassCalibrationResult.tolerance. Six more that are newer than 3.3.0 did in 4.0.0rc1, and the rest of the table arrived after 4.0.0rc1. Anything that built one by hand, or rewrote one with dataclasses.replace, could judge a measurement against any number and still print the standard’s name over the result. In 4.0 every limit a standard prints is a read-only property, read from the fields that select it: the bands, the condition, the source, the class, the room. A verdict that was stored beside its limit is read from the measured fields too, or checked against them when the result is built, so it cannot contradict the limit. The functions that return these verdicts take the same arguments and give the same answers, and every name below still reads the same value; only code that constructs a verdict directly, or replaces one of these fields, has to change. The last column says where each verdict first shipped.

Two calls change too. rigid_mass_calibration_check no longer takes tolerance: ISO 7626-2:2015 7.5.2 says the block “shall agree within ±5 %”, so a tighter in-house acceptance is read from .deviation instead. And HeavyImpactSourceCheck and RigidMassCalibrationResult, whose passes was a stored field, refuse to be read as a truth value like every other verdict, so if check: raises TypeError and the verdict is .passes.

import dataclasses

from phonometry import vibration

check = vibration.check_blocked_output([100.0, 200.0], [90.0, 95.0], [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.rigid_mass_calibration_check([0.104, 0.093], [50.0, 500.0], 10.0)
print(calibration.tolerance, calibration.within_tolerance.tolist())
# 0.05 [True, False]

The limits a standard leaves to the user stay fields: the “default” roughness and decay-rate limits of ISO 3095, the tolerance ISO/DIS 16032 7.6 does not print for “approximately 30 s”, the curing period a product specification sets under ISO 10140-1 G.4, the threshold shift ISO 8253-1 lets the tester accept, and the specification limits, test-case limits and limit rows the caller passes to the conformance, ISO 17534-1 and RD 1367/2007 checks. The requirement records of ISO 8297 and IEC 60118-4, PlantRequirement and LoopRequirement, also keep each row’s limit as a field: one record type holds requirements whose limits mix printed figures with the plant’s geometry, the specified field strength or the noise measured with the loop off.

The section above took the printed limits out of the constructors. The verdict flags stayed in: passes, complies, qualified, every *_met and *_ok, the advisories, and the class of each band of a filter, weighting or intensity instrument verdict. The function that built a result worked them out and stored them beside the readings they came from, so a result built by hand, or rewritten with dataclasses.replace, could hold readings that fail and a flag that says they pass. In 4.0 every one of them is a read-only property, read from the values the result holds and the limit the standard prints. A result keeps what its verdict is read from: the readings, the margins, the positions, the measured figures. A figure that only fed the verdict, such as the rounded level of an RD 1367/2007 period or the share of raindrops inside their tolerance, is a property too. The functions that return these results take the same arguments and return the same verdicts, and every name in the table still reads the same value; only code that builds one of these results directly, or replaces one of the listed fields, has to change. “By name only” marks a field that is keyword-only.

FilterComplianceResult and WeightingComplianceResult hold their per-band rows as band_margins: the rows bands held, without the "class" key. A row that states a class is refused, and the bands property adds to each row the class its margins earn, so result.bands[i]["class"] reads as before. IntensityInstrumentComplianceResult takes no band rows at all: it holds the frequencies and the measured pressure-residual intensity index, and reads the rows, the class and range_limited from them, the device and the microphone separation.

The rows a verdict is read from are read-only. band_margins and between_nominals are copied into read-only mappings when the result is built, so a write into one raises TypeError and a later write into the dictionaries you built it from does not move the class; copy a row with dict(row) to change it, since copy.deepcopy cannot copy a read-only mapping. The rows of AircraftSystemComplianceResult.checks, QuasiPeakDynamicsResult.stimuli and ReferenceTrackCheck.conditions are built from what the result holds and the tables of the standard each time they are read.

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

A flag stays a field where it is no verdict against a limit and nothing the result holds decides it: an option the caller sets, such as small_room or noise_is_tonal; a branch the caller chose by what they gave, such as InverseSquareLawResult.origin_fitted; a fact of an input the result does not keep, such as TimeWeightedEnvelope.calibrated; a property of the file read; whether an iterative solver converged; and a column of a published table row. CriticalCouplingResult.converged keeps the outcome of its solve, which the result cannot run again, but it can no longer claim convergence beside an absorption that does not exceed 0.999, the third condition of the flag. A regime the result could read from its own values is a verdict, and the next section lists the ones that moved. PlantRequirement and LoopRequirement do not change: their rows keep each limit as a field for the reason the section above gives, and PlantRequirement.holds stays beside it. TrackCondition keeps its holds as a row of the report, but ReferenceTrackCheck builds its conditions from the track it holds, so no verdict reads one built elsewhere. The yes/no checks of SoundLevelMeterPeriodicRequirement stay as well: they are what the tester saw, an overload indicated or an indicator latched, not a limit judged.

Some results stored a regime or a classification beside the values it was read from: the regime of a valve, whether a hammer rebounds, whether terrain screens a path, whether a tone was found, whether a synchronous average had to interpolate. The function compared values the result holds, or could hold, with a constant or a threshold its source prints, and stored the answer, so a result built by hand could hold the stiffness of an under-critical hammer and say it is over-critical. In 4.0 each of them is a read-only property, read from the values the result keeps, and a result that did not keep what the test reads now keeps it, with the unit in the name. “By name only” marks a field that is keyword-only.

A value exactly on a boundary falls where the source puts it. Hopkins prints the over-critical case as K m ≥ 4 Zdp², so critical damping is over-critical, and IEC TS 61400-11-2 asks for a total “at least 3 dB” above the background before the logarithmic subtraction, so a difference of 3 dB takes it. IEC 60534-8-4 does not settle its cavitation threshold one way: the test of 5.1 leaves the threshold itself to neither side, the region of Equation (9) and Equation (19b) put it with the cavitating points, and 4.1, Equation (18b) and 6.3 with the turbulent ones. The library reads it as turbulent, where Equation (9) returns zero and the two branches meet without a step.

The functions take the same arguments and return the same numbers. Code that builds one of these results directly, or replaces one of the fields its regime is read from, has to change, and so does code that reads band_type from vibration_reduction_index (see below the table).

building.VibrationReductionResult.band_type stays a field, as the band set the caller states: octave_bands() states "octave", since a single octave band cannot be told from a one-third-octave band by its spacing. vibration_reduction_index no longer fills it with the band set it read from the frequencies; it leaves None, and the result reads the spacing each time it takes the Annex A mean, which gives the same mean as before.

The numbers a regime selects are held to it, so a result built by hand can no longer carry one regime beside the values of another. When it is built, each of these results refuses:

• TappingForceResult: a cut-off frequency, a limiting frequency, a force spectrum or a power input that is not what K, Zdp and m give in their regime, and limits of Eqs. (3.99) and (3.100) that are not a factor of 2 apart.
• HydrodynamicValveNoise: a vapour pressure at or above the inlet pressure; an x_F or an x_Fzp1 that is not what Equation (1) or (3c) gives from the fields beside it; a point at or past flashing, x_F = 1; cavitation fields on a turbulent point, or none on a cavitating one.
• AerodynamicValveNoise: boundaries that are not those of its gas and its trim, and a Mach number or an acoustical efficiency of another regime.
• TerrainScreeningResult: a source or a receiver that is not a finite point, a source at or past the receiver, a section that does not run from one to the other, and a path difference or diffracting edges that are not those of the rubber band over that section.
• AutomaticThresholdResult and SweepThresholdResult: reversals that do not alternate, a tracing that keeps no peak or no valley, and a mean, a threshold or a running threshold that is not what the reversals give.
• WaveMotionCorrection: a frequency beyond the last row of Table C.3, and a correction the table does not give at its frequency.
• CabinInsulationResult: an A-weighted insulation under any method but the actual noise.
• WindTurbineTonalityResult: a candidate that is not a line of the spectrum at or above 20 Hz, and a Formula 30 to 34 chain that is not the one the spectrum gives about it.
• LabJointInsulationResult: a corrected index of another rule of J.1.
• TurbineSoundLevels: a level difference other than the total less the background, a turbine level of another rule of 11.7, and an uncertainty on a bin whose level cannot be determined.
• WestonPropagationResult: a composite loss that is not the law of the regime in force.
• SynchronousAverageResult: a period grid other than round(fs * period_s) samples.

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

Everything else moved. These ten exist in no public module:

Numbers. The conformance report is the same 995 checks against the same standards with the same expected values it had before the reorganisation, and every rename above was checked to return what its predecessor returned. If a result moves after you finish the upgrade, that is a defect and it is worth reporting.

One verdict is the exception, and the section on filter classes above says how: verify_filter_class grades the effective bandwidth of 5.12 and the summation of 5.16 as well as the Table 1 mask for the 2014 edition, and the filter integrated response of 4.5.3 and the summation of 4.9 for edition="1995", so a bank’s class is the strictest it meets on all three. Every band is graded at the bank’s input rate up to half of it, so the Table 1 margins of a decimated band take in the alias images its decimation folds onto it.

The decimated filter banks are the other: each band now keeps its processing Nyquist frequency sixteen times its upper edge and decimates through an anti-aliasing filter sized for a 120 dB stopband, so a band level moves by up to 0.07 dB on white noise, as the same section says.

What each .plot() draws is untouched, and so is what each .report() prints but one label: the microphone fiche writes dB(468) where it wrote dB(CCIR). The Signal contract is the one it was, now kept in two more places, the blocks of read_blocks and the waveforms inside five results. Every formula is untouched too. 4.0 rearranged the furniture and put the unit on the label; apart from those two, it did not recompute anything.