materials.resilient.dynamic_stiffness

Dynamic stiffness of resilient materials under floating floors (EN 29052-1:1992).

A floating floor is a heavy floating slab resting on a resilient layer; the combination is a mass-spring system whose natural frequency governs the impact and airborne improvement of the floor. EN 29052-1 (identical to ISO 9052-1:1989) measures the dynamic stiffness per unit area s' of the resilient layer from the resonance of a standard load plate on a 200 mm x 200 mm specimen.

The dynamic stiffness per unit area is the ratio of a dynamic force per area to the resulting change in thickness (Formula 1):

The resiliently supported floor is a mass-spring resonator; its natural frequency (Formula 2) and, in the laboratory arrangement, the measured resonant frequency (Formula 3) are:

so the apparent dynamic stiffness follows from the resonance (Formula 4):

With an air-permeable resilient material the enclosed gas adds a parallel stiffness (Formula 7), from the isothermal compression of the pore air:

($s_{\mathrm{a}}^{\prime }=111/d$ MN/m3 for $p_0=0.1$ MPa, $ϵ=0.9$ and d in mm, the standard’s worked NOTE). The dynamic stiffness of the installed material is then obtained by airflow resistivity r (clause 8.2):

For $r<10$ kPa.s/m2, s'a follows Formula 7; the method only applies when $s_{\mathrm{t}}^{\prime }\gg s_{\mathrm{a}}^{\prime }$, otherwise s' cannot be resolved.

This module is the resilient-layer characterisation feeding the floating-floor term of the EN 12354-2 impact model (phonometry.building.prediction.simplified_model). It does not feed ISO 16251-1 (phonometry.building.measurement.floor_covering_improvement), whose scope is limited to soft, locally-reacting floor coverings; floating floors are explicitly excluded there.

Auto-generated from the source docstrings by scripts/generate_api_docs.py (make api-docs). Do not edit by hand.

apparent_dynamic_stiffness(
    resonant_frequency_hz: ArrayLike,
    total_mass_per_area_kg_m2: float,
) -> np.ndarray | float

Apparent dynamic stiffness per unit area s't (Formula 4).

Inverts the test resonance $f_{\mathrm{r}}=(1/2\pi )\sqrt{s_{\mathrm{t}}^{\prime }/m_{\mathrm{t}}^{\prime }}$ to $s_{\mathrm{t}}^{\prime }=4{\pi }^2{m}_{\mathrm{t}}^{\prime }{f}_{\mathrm{r}}^2$.

Parameters

Returns: The apparent dynamic stiffness per unit area s't, in N/m3 (numerically MN/m3 when divided by 1e6).

DynamicStiffnessResult(
    apparent_stiffness: float,
    gas_stiffness: float,
    dynamic_stiffness: float,
    resonant_frequency: float,
    floor_mass_per_area: float,
    natural_frequency: float,
)

Dynamic stiffness of a resilient layer and the floating-floor resonance.

Attributes

DynamicStiffnessResult.plot(
    ax: Axes | None = None,
    *,
    language: str = 'en',
    **kwargs: Any,
) -> Axes

Plot f0(s') with this design point marked.

Requires matplotlib (pip install phonometry[plot]); returns the Axes.

DynamicStiffnessResult.report(
    path: str,
    *,
    metadata: ReportMetadata | None = None,
    engine: str = 'reportlab',
    verbose: bool = False,
    language: str = 'en',
) -> str

Render an EN 29052-1 dynamic-stiffness test-report fiche to a PDF.

Writes a one-page accredited dynamic-stiffness report (EN 29052-1:1992, identical to ISO 9052-1:1989): the standard-basis line, an optional metadata header block (client, specimen, the total mass per unit area m't used during the test, the loaded specimen thickness d, test facility, date, climate …), a two-panel body with a compact metrics table (the resonant frequency fr, the apparent dynamic stiffness s't of Formula 4, the enclosed-gas term s'a of Formula 7 when it applies, the installed dynamic stiffness s' of Clause 8.2 and the supported-floor natural frequency f0 of Formula 2) beside the f0(s') design curve, a boxed apparent dynamic stiffness s't with the installed s' and the resonance fr alongside, and a footer with the fixed disclaimer. EN 29052-1 is a characterisation, so there is no pass/fail verdict.

Clause 9 requires every dynamic stiffness per unit area to be stated in meganewtons per cubic metre to the nearest meganewton per cubic metre, so the stiffness values are rounded to the nearest MN/m3; the frequencies are shown to 0,1 Hz.

Parameters

Returns: The written path as a str.

Raises

Advisory when the enclosed-gas term makes s' unresolvable (clause 8.2).

enclosed_gas_stiffness(
    thickness_m: ArrayLike,
    porosity: float,
    *,
    atmospheric_pressure_pa: float = 100000.0,
) -> np.ndarray | float

Enclosed-gas dynamic stiffness per unit area s'a (Formula 7).

The isothermal compression of the pore air adds a stiffness in parallel with the material’s structure: $s_{\mathrm{a}}^{\prime }=p_0/(dϵ)$.

Parameters

Returns: The enclosed-gas dynamic stiffness per unit area s'a, in N/m3.

floating_floor_resonance(
    resonant_frequency_hz: float,
    total_mass_per_area_kg_m2: float,
    floor_mass_per_area_kg_m2: float,
    *,
    airflow_resistivity_kpa_s_m2: float = inf,
    thickness_m: float | None = None,
    porosity: float | None = None,
    atmospheric_pressure_pa: float = 100000.0,
) -> DynamicStiffnessResult

Full EN 29052-1 chain: measured resonance -> installed s' and f0.

Chains the apparent dynamic stiffness (Formula 4), the enclosed-gas term (Formula 7, when thickness_m and porosity are given), the airflow resistivity combination (clause 8.2) and the installed-floor natural frequency (Formula 2).

Parameters

Returns: The DynamicStiffnessResult.

installed_dynamic_stiffness(
    apparent_stiffness_n_m3: float,
    *,
    airflow_resistivity_kpa_s_m2: float,
    gas_stiffness_n_m3: float | None = None,
) -> float

Dynamic stiffness per unit area s' of the installed material (clause 8.2).

Combines the apparent stiffness with the enclosed-gas term according to the lateral airflow resistivity r:

• $r\ge 100$ kPa.s/m2 -> $s^{\prime }=s_{\mathrm{t}}^{\prime }$ (Formula 5);
• $10\le r<100$ kPa.s/m2 -> $s^{\prime }=s_{\mathrm{t}}^{\prime }+s_{\mathrm{a}}^{\prime }$ (Formula 6);
• $r<10$ kPa.s/m2 -> the standard only requires the qualitative criterion $s_{\mathrm{t}}^{\prime }\gg s_{\mathrm{a}}^{\prime }$ (clause 8.2). This implementation applies its own engineering threshold: s'a below 10 % of s't is treated as negligible and $s^{\prime }=s_{\mathrm{t}}^{\prime }$ (a DynamicStiffnessWarning is emitted; clause 8.2 requires the error caused by disregarding s'a to be stated in the test report); above it the result is nan, as the method cannot resolve s'.

The airflow resistivity is in kilopascal seconds per square metre, the unit clause 8.2 states its thresholds in, and it is asked for by name because the flow resistivities this library holds elsewhere (flow_resistivity_pa_s_m2) are in pascal seconds per square metre, a thousand times smaller a unit.

Parameters

Returns: The installed dynamic stiffness per unit area s', in N/m3 (nan when the method cannot resolve it).

Raises

natural_frequency(
    dynamic_stiffness_n_m3: ArrayLike,
    mass_per_area_kg_m2: float,
) -> np.ndarray | float

Natural frequency f0 of the resiliently supported floor (Formula 2).

$f_0=(1/2\pi )\sqrt{s^{\prime }/m^{\prime }}$.

Parameters

Returns: The natural frequency f0, in hertz.

plot_dynamic_stiffness_rig(
    ax: Axes | None = None,
    *,
    specimen_side: float = 0.2,
    specimen_thickness: float = 0.02,
    load_mass: float = 8.0,
    language: str = 'en',
    **kwargs: Any,
) -> Axes

Draw the dynamic-stiffness resonance rig to scale.

Resilient specimen on the rigid base, the standard square load plate on top (its mass annotated), the exciter above and an accelerometer on the plate; defaults are the standard 200 mm square specimen under the 8 kg plate.

Parameters

Returns: The axes.

Raises

Constant (mapping).

resilient_layer(layer: str | ResilientLayer) -> ResilientLayer

Look up a published resilient layer, or pass one through.

Parameters

Returns: The ResilientLayer.

Raises

ResilientLayer(
    *,
    name: str,
    source: str,
    table: str = '',
    variant: str = '',
    basis: Mapping[str, str] = ...,
    approximate: frozenset[str] = frozenset(),
    derived: Mapping[str, str] = ...,
    converted: Mapping[str, tuple[str, str]] = ...,
    carried: Mapping[str, str] = ...,
    ranges: Mapping[str, tuple[float | None, float | None]] = ...,
    bounded_above: frozenset[str] = frozenset(),
    bounded_below: frozenset[str] = frozenset(),
    reported: Mapping[str, tuple[float | tuple[float, float], ...]] = ...,
    unquantified: Mapping[str, str] = ...,
    uncertainty: Mapping[str, float] = ...,
    not_derivable: Mapping[str, str] = ...,
    misprinted: Mapping[str, str] = ...,
    attributed_to: Mapping[str, str] = ...,
    group: str = '',
    note: str = '',
    dynamic_stiffness_n_m3: float | None = None,
    apparent_dynamic_stiffness_n_m3: float | None = None,
    density_kg_m3: float | None = None,
    thickness_mm: float | None = None,
)

A resilient layer under a floating floor, as its source prints it.

A row of a catalogue like every other (CatalogueRow): every quantity is optional, because a source prints some columns and not others, and a cell that holds something other than a number, such as the bound s' <= 9 MN/m3 a product declaration prints, is held by the row’s hedges rather than turned into one.

EN 29052-1 names two stiffnesses per unit area, and they are two fields here. The test measures the apparent stiffness s't of a specimen whose pore air escapes at its sides (Formula 4); clause 8.2 turns it into the stiffness s' of the installed layer, whose pore air cannot, by way of the lateral airflow resistivity r and the enclosed-gas stiffness s'a. Formula 2 takes s'. A source that prints s' fills dynamic_stiffness_n_m3, which is what Hopkins Table A3 does. A test report gives s't and s'a, and s' only “if possible” (clause 9 e)); one that leaves s' out, like a sheet that gives s't alone, fills apparent_dynamic_stiffness_n_m3, and natural_frequency then needs r, and below 100 kPa.s/m2 the report’s s'a, to go on.

Attributes

ResilientLayer.basis_of(field_name: str) -> str

What the source says this field is, one of CATALOGUE_BASES.

The five are measured, declared, calculated, estimated and extended.

Parameters

Returns: The field’s own entry in basis, else the row’s, else the empty string, which means the source does not say.

classmethod

ResilientLayer.from_printed(**cells: Any) -> Self

A row built from the cells its page prints, completed and marked.

The one path that works anything out. The cells are what the page prints, under the field names of the class and with the hedges each cell carries, as a data file writes them. A figure written under a unit the class takes as an alias of its own (an AbsorptionAreaSpectrum takes absorption_area_125_ft2 for absorption_area_125_m2) is converted on its digits with an exact factor and rounded once, and converted records the figure and its unit. The row is then built and held to the contract the class docstring lists, so every cell is checked before any arithmetic reads it. Last, the class fills what follows from those cells (a modulus from a plate speed, a density and a Poisson ratio), never over a cell that holds a value or one the row says something else about, and derived says how each filled value was reached and, when the cells it rests on do not share one basis, the basis of each. Cells the arithmetic cannot take are refused rather than turned into a value that would be wrong: a modulus of 1 GPa and a shear modulus of 0.1 GPa give a Poisson ratio of 4, which no isotropic solid has, and a row whose cells are not meant to give a value says so in not_derivable, which keeps the arithmetic from running.

Cls(...) stays literal: it holds what it is given and works nothing out. To change a cell of a row and have what follows from it follow again, change it in printed_fields and build again here; dataclasses.replace would copy the derived values as they were:

cells = row.printed_fields()
cells["density_kg_m3"] = 2400.0
row = type(row).from_printed(**cells)

Parameters

Returns: The row, with what follows from its cells filled in.

Raises

ResilientLayer.is_approximate(field_name: str) -> bool

Whether the page prints this field with a ~.

Parameters

Returns: True when the page rounded the cell on purpose.

ResilientLayer.is_derived(field_name: str) -> bool

Whether this library computed this field instead of reading it.

Parameters

Returns: True when the page did not print it and the value follows from cells that it did. derived says how. A value the page prints in another unit, or gives by reference to another of its rows, answers False: the number is the page’s, and converted or carried says so.

ResilientLayer.natural_frequency(
    mass_per_area_kg_m2: float,
    *,
    airflow_resistivity_pa_s_m2: float | None = None,
    gas_stiffness_n_m3: float | None = None,
) -> float

f0 of a floor of this mass per unit area on this layer.

$f_0=(1/2\pi )\sqrt{s^{\prime }/m^{\prime }}$ (Formula 2), through the module’s natural_frequency.

A row that gives s' is used as it is, and the two keywords are refused, because nothing would read them. A row that gives only the apparent s't goes through installed_dynamic_stiffness first, which is clause 8.2: s' = s't at or above 100 kPa.s/m2, s' = s't + s'a from 10 up to 100, and below 10 s' = s't only while s'a is negligible (nan, with a DynamicStiffnessWarning, when it is not).

The resistivity is taken in pascal seconds per square metre, the unit every flow resistivity of this library’s catalogues is held in, and divided by a thousand for the kilopascal thresholds of clause 8.2. The division is correctly rounded and never decreases as its input grows, so it carries no resistivity across either threshold: exactly 100 000 or 10 000 Pa.s/m2 lands on 100 or 10, and the largest float below either lands below it. The formula chosen is always the one the resistivity passed picks.

Parameters

Returns: The natural frequency f0, in hertz.

Raises

ResilientLayer.printed(
    field_name: str,
    *,
    wanted_by: str = 'the caller',
) -> float

One quantity this page prints, or a refusal that says what it had.

Every quantity of a row is optional, because the pages print different columns, so a caller passing one into a function that requires a float has to narrow it. Doing it here beats an assertion at each call site: the refusal names the field, who wanted it and what the page had in that cell, which is the difference between a cell the book left empty and a cell holding the word “model”.

Parameters

Returns: The value, as a float.

Raises

ResilientLayer.printed_fields() -> dict[str, Any]

The cells the page prints, as from_printed takes them.

Every field, the name, the citation, the table and every hedge included, except the values this library derived, derived itself, and a field left at a default that holds nothing (a quantity the page leaves out, an empty text or hedge). A text field whose default says something is kept even when it holds no text: the per of an area per unit is a person unless the row says otherwise, and a row that leaves it empty has said otherwise. A value converted from the page’s unit and one the page gives by reference to another of its rows are the page’s, so they stay, with converted and carried beside them.

For every row from_printed builds, and so for every packaged one, type(row).from_printed(**row.printed_fields()) is the row again, and changing a cell before building it again is how a row is edited without carrying a derived value that no longer follows from it. A derived passed to the literal constructor is the caller’s own; it is left out here with its value, like every derived one, so building again gives back only what the class works out.

Returns: A new dictionary of constructor keywords. The values are the ones the row holds, frozen as the row holds them.

ResilientLayer.why_missing(field_name: str) -> str

Why this field is None, in the page’s own terms.

A catalogue that answers None and stops is asking the caller to guess whether the material has no such property, whether the book measured it and printed a dash, or whether the cell holds something that is not a number. Each of those is a different answer.

Parameters

Returns: What the page had in that cell, or the empty string when the field is not missing at all. A field the page has no column for and this library cannot derive, because the cells it would need are themselves a range, answers that it does not follow.

Raises