Adds photon mass attenuation calculations

src/dodal/common/general_maths/material_absorption_maths.py

@@ -0,0 +1,19 @@
+def photon_mass_attenuation_per_unit_length(
+    energy_kev: float,
+    photon_absorption_factor_per_unit_length: float,
+    energy_dependence_exponent: float,
+):
+    """Calculates mass attenuation per unit length.
+
+    Args:
+        energy_kev (float): energy
+        photon_absorption_factor_per_unit_length (float): photon absorption factor per
+        unit length
+        energy_dependence_exponent (float): energy dependence exponent
+
+    Returns:
+        (float): mass attenuation per unit length.
+    """
+    return photon_absorption_factor_per_unit_length * (
+        energy_kev**energy_dependence_exponent
+    )

src/dodal/common/general_maths/transmission_interconversion.py

@@ -0,0 +1,56 @@
+import math
+
+canonical_barnett_conversion = -1.0e3
+reverse_barnett_conversion = -1.0e-3
+
+
+def attenuation_from_natural_log_of_transmission(ln_t: float):
+    """Converts from natural log of transmission fraction into Barnett attenuation units
+    .
+
+    Args:
+        ln_t (float): natural log of transmission fraction
+
+    Returns:
+        (float): Barnett attenuation units
+    """
+    return canonical_barnett_conversion * ln_t
+
+
+def attenuation_from_transmission(transmission_as_fraction: float):
+    """Converts from transmission fraction into Barnett attenuation units.
+
+    Args:
+        transmission_as_fraction (float): transmission fraction
+
+    Returns:
+        (float): Barnett attenuation units.
+    """
+    ln_t = math.log(transmission_as_fraction)
+    return attenuation_from_natural_log_of_transmission(ln_t)
+
+
+def natural_log_of_transmission_from_attenuation(attenuation_bn: float):
+    """Converts from Barnett attenuation units into natural log of transmission fraction
+    .
+
+    Args:
+        attenuation_bn (float): Barnett attenuation units
+
+    Returns:
+        (float): natural log of transmission fraction
+    """
+    return reverse_barnett_conversion * attenuation_bn
+
+
+def transmission_from_attenutation(attenuation_bn: float):
+    """Converts from Barnett attenuation units into transmission fraction.
+
+    Args:
+        attenuation_bn (float): Barnett attenuation units
+
+    Returns:
+        (float): transmission fraction
+    """
+    ln_t = natural_log_of_transmission_from_attenuation(attenuation_bn)
+    return math.exp(ln_t)

tests/common/general_maths/test_material_absorption_maths.py

@@ -0,0 +1,52 @@
+import math
+
+import pytest
+
+from dodal.common.general_maths import material_absorption_maths
+
+
+# happy path
+@pytest.mark.parametrize(
+    "energy_kev,photon_absorption_factor_per_unit_length,energy_dependence_exponent,"
+    "result",
+    [
+        (5.042, 1.98e2, -2.717, 2.44170544),  # Arbitrary
+        (8.3328, 2.5706e3, -2.83, 6.3708311),  # Nickel
+        (11.9187, 1.48e3, -2.93, 1.03970725),  # Gold-Three
+        (25.514, 6.48e3, -2.41, 2.63778077),  # Silver
+    ],
+)
+def test_photon_mass_attenuation_per_unit_length(
+    energy_kev,
+    photon_absorption_factor_per_unit_length,
+    energy_dependence_exponent,
+    result,
+):
+    assert material_absorption_maths.photon_mass_attenuation_per_unit_length(
+        energy_kev, photon_absorption_factor_per_unit_length, energy_dependence_exponent
+    ) == pytest.approx(result)
+
+
+# inauspicious path
+@pytest.mark.parametrize("bad_input", ["a", [], None, math.sin, object()])
+def test_photon_mass_attenuation_per_unit_length_errors_energy(bad_input):
+    with pytest.raises(TypeError):
+        material_absorption_maths.photon_mass_attenuation_per_unit_length(
+            bad_input, 1.0, 1.0
+        )
+
+
+@pytest.mark.parametrize("bad_input", ["a", [], None, math.sin, object()])
+def test_photon_mass_attenuation_per_unit_length_errors_absorp(bad_input):
+    with pytest.raises(TypeError):
+        material_absorption_maths.photon_mass_attenuation_per_unit_length(
+            1.0, bad_input, 1.0
+        )
+
+
+@pytest.mark.parametrize("bad_input", ["a", [], None, math.sin, object()])
+def test_photon_mass_attenuation_per_unit_length_errors_expo(bad_input):
+    with pytest.raises(TypeError):
+        material_absorption_maths.photon_mass_attenuation_per_unit_length(
+            1.0, 1.0, bad_input
+        )

tests/common/general_maths/test_transmission_interconversion.py

@@ -0,0 +1,76 @@
+import math
+
+import pytest
+
+from dodal.common.general_maths import transmission_interconversion
+
+
+# happy:
+@pytest.mark.parametrize(
+    "ln_t,result", [(-1, 1000), (0, 0), (-0.4367, 436.7), (-5.9017, 5901.7)]
+)
+def test_attenuation_from_natural_log_of_transmission(ln_t, result):
+    assert transmission_interconversion.attenuation_from_natural_log_of_transmission(
+        ln_t
+    ) == pytest.approx(result)
+
+
+@pytest.mark.parametrize(
+    "transmission_as_fraction,result",
+    [(1, 0), (0.37, 994.25227334), (0.871, 138.1133), (4.2e-4, 7775.2558)],
+)
+def test_attenuation_from_transmission(transmission_as_fraction, result):
+    assert transmission_interconversion.attenuation_from_transmission(
+        transmission_as_fraction
+    ) == pytest.approx(result)
+
+
+@pytest.mark.parametrize(
+    "attenuation_bn,result",
+    [(0, 0), (1e3, -1), (712.6, -0.7126), (8034.1, -8.0341)],
+)
+def test_natural_log_of_transmission_from_attenuation(attenuation_bn, result):
+    assert transmission_interconversion.natural_log_of_transmission_from_attenuation(
+        attenuation_bn
+    ) == pytest.approx(result)
+
+
+@pytest.mark.parametrize(
+    "attenuation_bn,result",
+    [(0, 1), (1e3, 0.3678794), (145.1, 0.8649358), (7221.9, 7.3041331435179e-4)],
+)
+def test_transmission_from_attenutation(attenuation_bn, result):
+    assert transmission_interconversion.transmission_from_attenutation(
+        attenuation_bn
+    ) == pytest.approx(result)
+
+
+# inauspicious:
+
+
+@pytest.mark.parametrize("bad_input", ["a", [], None, math.sin, object()])
+def test_attenuation_from_natural_log_of_transmission_errors(bad_input):
+    with pytest.raises(TypeError):
+        transmission_interconversion.attenuation_from_natural_log_of_transmission(
+            bad_input
+        )
+
+
+@pytest.mark.parametrize("bad_input", ["a", [], None, math.sin, object()])
+def test_attenuation_from_transmission_errors(bad_input):
+    with pytest.raises(TypeError):
+        transmission_interconversion.attenuation_from_transmission(bad_input)
+
+
+@pytest.mark.parametrize("bad_input", ["a", [], None, math.sin, object()])
+def test_natural_log_of_transmission_from_attenuation_errors(bad_input):
+    with pytest.raises(TypeError):
+        transmission_interconversion.natural_log_of_transmission_from_attenuation(
+            bad_input
+        )
+
+
+@pytest.mark.parametrize("bad_input", ["a", [], None, math.sin, object()])
+def test_transmission_from_attenutation_errors(bad_input):
+    with pytest.raises(TypeError):
+        transmission_interconversion.transmission_from_attenutation(bad_input)