fluids.nonlinearity

The nonlinearity parameter B/A of liquids, as a handbook tabulates it.

Sound in a fluid is linear only in the limit of a vanishing amplitude. At a finite one the pressure is not proportional to the change in density, and the first term of the departure is what B/A measures. Expanding the adiabatic pressure in the condensation s = (rho - rho0) / rho0 gives p - p0 = A s + (B/2) s**2 + ..., with A = rho0 (dp/drho)_s, which is rho0 c0**2, and B = rho0**2 (d2p/drho2)_s: Rossing’s equations (8.7) to (8.9). B/A is the ratio of those two, dimensionless. It sets how fast a finite wave steepens towards a shock, how strongly two beams generate their sum and difference frequencies, and with it the output of a parametric array; the coefficient of nonlinearity is 1 + B/(2A). In the rows below water sits between 4.2 and 6.2, the organic liquids mostly between 6 and 12, the liquid metals between 2.7 and 7.8, and air, for comparison, is 0.4 because an ideal gas has B/A = gamma - 1.

Each row is one published value: a substance, the temperature it was measured at, the value, and the paper it comes from. Three of Rossing’s tables print a reference beside every value and the fourth credits one paper in its caption, and that is not decoration: at 30 °C water prints four values between 5.18 and 5.38 from four papers, and toluene prints 5.6 at 20 °C from one paper and 8.929 at 30 °C from another. A caller who wants “the” B/A of a liquid has to choose, and the row carries in attributed_to the full reference the chapter’s list gives for that number, so that the choice can be made on the paper and not on the digits. Where the page prints a plus-or-minus beside the value it is in uncertainty.

Table 8.2 is the only one that prints a pressure, from 0.1 to 50 MPa, and its rows carry it; the other three say “at atmospheric pressure” in the caption and print no number, so their rows hold none rather than a 101 325 Pa the page did not write. For six of the liquefied gases of Table 8.4 the caption cannot be right: they are above their normal boiling point, liquid only under a pressure the page does not give, and their rows say so.

It is not a model. Nothing here interpolates between two temperatures or between two papers, and no function in this library computes B/A from a sound speed yet; a caller who needs a value at 25 °C where the table prints 20 and 30 has to decide how, and between which references.

In fluids/data/rossing-2014-table-8-1.json to -8-4.json, one file per printed table, read at import through the package-data reader in phonometry._internal, the same as every other catalogue here.

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

nonlinearity_named(name: str) -> tuple[NonlinearityParameter, ...]

Every published value whose substance name contains name.

Parameters

Returns: The matching rows, in the order the tables list them. Empty when nothing matches, which is not an error.

NonlinearityParameter(
    *,
    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 = '',
    b_over_a: float | None = None,
    temperature_c: float | None = None,
    static_pressure_pa: float | None = None,
    year: int | None = None,
)

One published value of B/A, with the conditions it was measured at.

Attributes

NonlinearityParameter.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

NonlinearityParameter.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

NonlinearityParameter.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.

NonlinearityParameter.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.

NonlinearityParameter.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

NonlinearityParameter.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.

NonlinearityParameter.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

Constant (mapping).