Skip to content

index

The clearance index itself, and the result it returns.

index

The clearance index itself: a sum of activity-to-limit ratios.

Every regulation here uses the same arithmetic. Each radionuclide's activity is divided by its tabulated limit and the ratios are summed; a total below one means the material meets the limits. The German regulation calls it the Summenformel, the UK calls it the summation rule, the NRC calls it the sum of fractions rule and Fetter calls the result a waste disposal rating. This module implements it once.

What differs between regulations, and what ClearanceResult therefore records, is what happens to a nuclide that is not simply looked up: one whose parent already accounts for it, one the table does not list, and one the regulation places outside its scope entirely.

Classes:

  • ClearanceResult –

    The outcome of assessing one material against one limit set.

Functions:

ClearanceResult dataclass 

ClearanceResult(limit_set: str, index: float, threshold: float, units: str, by_nuclide: dict[str, float] = dict(), activities: dict[str, float] = dict(), limits_used: dict[str, float] = dict(), defaulted: tuple[str, ...] = (), excluded: dict[str, str] = dict(), credited: dict[str, float] = dict(), uncovered: dict[str, float] = dict(), unlimited: tuple[str, ...] = (), out_of_scope: bool = False, material_name: str = '')

The outcome of assessing one material against one limit set.

Attributes:

  • limit_set (str) –

    Name of the set assessed against.

  • index (float) –

    The sum of activity-to-limit ratios.

  • threshold (float) –

    The value the index must stay below, normally 1.

  • units (str) –

    Activity units the comparison was made in.

  • by_nuclide (dict[str, float]) –

    Each nuclide's contribution to the index, largest first.

  • activities (dict[str, float]) –

    Each nuclide's activity in units.

  • limits_used (dict[str, float]) –

    The limit applied to each nuclide, after any metal, per-gram or dynamic adjustment.

  • defaulted (tuple[str, ...]) –

    Nuclides that took the set's catch-all limit because the table does not list them.

  • excluded (dict[str, str]) –

    Nuclide to the reason its activity was left out, which is always that a parent's limit already accounts for it in full.

  • credited (dict[str, float]) –

    Nuclide to the activity a parent accounted for, where the parent could only support part of it. The remainder was assessed against the nuclide's own limit in the usual way, so for these nuclides the ratio in by_nuclide is computed from activities[name] - credited[name] rather than from the full activity. assessed_activity returns that residual directly.

  • uncovered (dict[str, float]) –

    Activity present with no limit and no catch-all, so absent from the index entirely. The number to check before trusting a comfortable index.

  • unlimited (tuple[str, ...]) –

    Nuclides the source explicitly places no limit on.

  • out_of_scope (bool) –

    Whether the regulation excludes this material outright, which for the UK sets means every radionuclide present is shorter lived than 100 seconds.

  • material_name (str) –

    The material's label, carried through for reporting.

Methods:

  • assessed_activity –

    The activity actually charged against the limit for one nuclide.

  • dominant –

    The nuclides contributing most to the index.

  • to_dict –

    A JSON-serialisable copy of the result.

clearable property 

clearable: bool

Whether the material meets this set's limits.

uncovered_activity property 

uncovered_activity: float

Total activity with no limit, in this result's units.

uncovered_fraction property 

uncovered_fraction: float

Share of total activity that falls outside the sum, from 0 to 1.

A large value means the index understates the inventory: activity is present that no limit in this set applies to. Zero means every radionuclide present was either limited or explicitly unlimited.

assessed_activity 

assessed_activity(nuclide: str) -> float

The activity actually charged against the limit for one nuclide.

The same as its total activity, except where a parent accounted for part of it, in which case the remainder is what the ratio was computed from.

Parameters:

  • nuclide
    (str) –

    Canonical nuclide name.

dominant 

dominant(count: int = 10) -> list[tuple[str, float]]

The nuclides contributing most to the index.

Parameters:

  • count
    (int, default: 10 ) –

    How many to return.

to_dict 

to_dict() -> dict

A JSON-serialisable copy of the result.

clearance_index 

clearance_index(material: Material, limit_set: str | LimitSet, *, metal: bool = False, apply_default_limit: bool = True, exclude_daughters: bool = True) -> ClearanceResult

Assess a material against one set of clearance limits.

Parameters:

  • material

    (Material) –

    The inventory to assess.

  • limit_set

    (str | LimitSet) –

    A registered limit set name, or a LimitSet.

  • metal

    (bool, default: False ) –

    Whether the material is activated metal, which changes some NRC limits and adds others.

  • apply_default_limit

    (bool, default: True ) –

    Whether to apply the set's catch-all limit to nuclides the table does not list. The UK regulations define one, so leaving this on is what the regulation says; turning it off shows what the listed nuclides alone contribute.

  • exclude_daughters

    (bool, default: True ) –

    Whether to leave out daughters whose parent's limit already covers them, per the regulation's own table. Turning this off double counts them, which is conservative but not what the regulation intends.

Returns:

  • ClearanceResult –

    A ClearanceResult carrying the index and everything needed to

  • ClearanceResult –

    judge it, including any activity that fell outside the sum.

Raises:

  • KeyError –

    If the limit set name is not registered.

  • InsufficientDataError –

    If a volumetric set is used and the material has no density.

clearance_indices 

clearance_indices(material: Material, names: 'list[str] | tuple[str, ...] | None' = None, **kwargs) -> dict[str, ClearanceResult]

Assess a material against many limit sets at once.

Sets whose units the material cannot supply, such as a volumetric set for a material with no density, are skipped rather than raising, so one missing density does not hide every result that does not need it.

Parameters:

  • material

    (Material) –

    The inventory to assess.

  • names

    ('list[str] | tuple[str, ...] | None', default: None ) –

    Limit set names, defaulting to every registered set.

  • **kwargs

    –

    Passed through to clearance_index.

Returns:

clearable_routes 

clearable_routes(material: Material, names: 'list[str] | tuple[str, ...] | None' = None, **kwargs) -> list[str]

The limit sets this material already meets, best margin first.

Parameters:

  • material

    (Material) –

    The inventory to assess.

  • names

    ('list[str] | tuple[str, ...] | None', default: None ) –

    Limit set names, defaulting to every registered set.

  • **kwargs

    –

    Passed through to clearance_index.

Returns:

  • list[str] –

    Names of the sets whose index is below their threshold.