Implement comprehensive density unit conversion with tests

- Expand Density.py with SI, chemistry, imperial and metric ton units
- Add @normalize_args + DensityKgPerM3 to Cylinder.py weight functions
- Import density normalization from Density.py in Viscosity.py (remove duplication)
- Fix numpy string scalar handling in _normalize.py (np.generic -> np.number)
- Add comprehensive tests for all units, iterables, and integration

Author: Uli Köhler

UliEngineering/Math/Geometry/Cylinder.py

@@ -3,9 +3,10 @@
 """Geometry functions for cylinders and hollow cylinders."""
 import math
 from .Circle import circle_area
-from UliEngineering.EngineerIO.Decorators import returns_unit
+from UliEngineering.EngineerIO.Decorators import normalize_args, returns_unit
 from UliEngineering.EngineerIO import normalize_numeric
 from UliEngineering.EngineerIO.Types import NormalizableArgument
+from UliEngineering.Physics.Density import DensityKgPerM3
 import numpy as np
 
 __all__ = [
@@ -44,37 +45,31 @@ def hollow_cylinder_volume(outer_radius: NormalizableArgument, inner_radius: Nor
     height = normalize_numeric(height) if isinstance(height, str) else height
     return cylinder_volume(outer_radius, height) - cylinder_volume(inner_radius, height)
 
-def cylinder_weight_by_diameter(diameter: NormalizableArgument, length: NormalizableArgument, density: NormalizableArgument = 8000):
+@normalize_args
+def cylinder_weight_by_diameter(diameter: NormalizableArgument, length: NormalizableArgument, density: DensityKgPerM3 = 8000):
     """Compute the weight of a cylinder by its diameter, length and density.
 
     The density is in kg/m³, the diameter and length must be given in mm.
     The default density is an approximation for steel.
     """
-    diameter = normalize_numeric(diameter) if isinstance(diameter, str) else diameter
-    length = normalize_numeric(length) if isinstance(length, str) else length
-    density = normalize_numeric(density) if isinstance(density, str) else density
     return cylinder_volume(diameter/2., length) * density
 
-def cylinder_weight_by_radius(radius: NormalizableArgument, length: NormalizableArgument, density: NormalizableArgument = 8000):
+@normalize_args
+def cylinder_weight_by_radius(radius: NormalizableArgument, length: NormalizableArgument, density: DensityKgPerM3 = 8000):
     """Compute the weight of a cylinder by its radius, length and density.
 
     The density is in kg/m³, the radius and length must be given in mm.
     The default density is an approximation for steel.
     """
-    radius = normalize_numeric(radius) if isinstance(radius, str) else radius
-    length = normalize_numeric(length) if isinstance(length, str) else length
-    density = normalize_numeric(density) if isinstance(density, str) else density
     return cylinder_volume(radius, length) * density
 
-def cylinder_weight_by_cross_sectional_area(area: NormalizableArgument, length: NormalizableArgument, density: NormalizableArgument = 8000):
+@normalize_args
+def cylinder_weight_by_cross_sectional_area(area: NormalizableArgument, length: NormalizableArgument, density: DensityKgPerM3 = 8000):
     """Compute the weight of a cylinder by its cross-sectional area, length and density.
 
     The density is in kg/m³, the area and length must be given in mm² and mm.
     The default density is an approximation for steel.
     """
-    area = normalize_numeric(area) if isinstance(area, str) else area
-    length = normalize_numeric(length) if isinstance(length, str) else length
-    density = normalize_numeric(density) if isinstance(density, str) else density
     return area * length * density
 
 @returns_unit("m")

UliEngineering/Physics/Density.py

@@ -62,12 +62,32 @@ def normalize_density_kg_per_m3(density: NormalizableArgument) -> NormalizedComp
     return normalize_with_known_units(
         density,
         {
+            # SI units
+            "kg/m³": 1.0,
             "kg/m^3": 1.0,
             "kg/m3": 1.0,
+            # Chemistry / common lab units
+            "g/cm³": 1000.0,
             "g/cm^3": 1000.0,
             "g/cm3": 1000.0,
+            "kg/L": 1000.0,
+            "kg/l": 1000.0,
+            "g/mL": 1000.0,
+            "g/ml": 1000.0,
             "g/L": 1.0,
             "g/l": 1.0,
+            # Imperial units
+            "lb/ft³": 16.0184634,
+            "lb/ft3": 16.0184634,
+            "lb/in³": 27679.9047,
+            "lb/in3": 27679.9047,
+            "lb/gal": 119.826427,
+            "oz/in³": 1729.994,
+            "oz/in3": 1729.994,
+            # Tonne / metric ton
+            "t/m³": 1000.0,
+            "t/m^3": 1000.0,
+            "t/m3": 1000.0,
         },
         quantity_name="density",
     )

UliEngineering/Physics/Viscosity.py

@@ -28,6 +28,7 @@
 from UliEngineering.EngineerIO.Decorators import returns_unit
 from UliEngineering.EngineerIO.Types import NormalizableArgument, NormalizedComputable
 from UliEngineering.Physics.Temperature import TemperatureKelvin, normalize_temperature
+from UliEngineering.Physics.Density import normalize_density_kg_per_m3, DensityKgPerM3
 from ._normalize import normalize_with_known_units
 
 __all__ = [
@@ -73,8 +74,8 @@
 def normalize_dynamic_viscosity(viscosity: NormalizableArgument) -> NormalizedComputable:
     return normalize_with_known_units(viscosity, {"Pa·s": 1.0, "Pa s": 1.0, "Pas": 1.0, "mPa·s": 1e-3, "cP": 1e-3, "P": 0.1}, quantity_name="dynamic viscosity")
 
-def normalize_density(density: NormalizableArgument) -> NormalizedComputable:
-    return normalize_with_known_units(density, {"kg/m³": 1.0, "kg/m3": 1.0, "kg/m^3": 1.0, "g/cm³": 1000.0, "g/cm3": 1000.0, "g/L": 1.0}, quantity_name="density")
+# Re-export density normalizer from Density.py for backward compatibility
+normalize_density = normalize_density_kg_per_m3
 
 def normalize_length(length: NormalizableArgument) -> NormalizedComputable:
     return normalize_with_known_units(length, {"m": 1.0, "mm": 1e-3, "cm": 1e-2, "km": 1e3, "µm": 1e-6, "nm": 1e-9}, quantity_name="length")
@@ -89,7 +90,7 @@ def normalize_shear_rate(shear_rate: NormalizableArgument) -> NormalizedComputab
     return normalize_with_known_units(shear_rate, {"s⁻¹": 1.0, "/s": 1.0}, quantity_name="shear rate")
 
 DynamicViscosityPas = Annotated[NormalizedComputable, normalize_dynamic_viscosity]
-DensityKgM3 = Annotated[NormalizedComputable, normalize_density]
+DensityKgM3 = DensityKgPerM3
 LengthMeter = Annotated[NormalizedComputable, normalize_length]
 PressurePascal = Annotated[NormalizedComputable, normalize_pressure]
 VelocityMS = Annotated[NormalizedComputable, normalize_velocity]

UliEngineering/Physics/_normalize.py

@@ -33,7 +33,7 @@ def normalize_with_known_units(
             dtype=float,
         )
 
-    if isinstance(value, (int, float, np.generic)):
+    if isinstance(value, (int, float, np.number)):
         return float(value) * default_factor
 
     if isinstance(value, bytes):

tests/Physics/TestDensity.py

@@ -1,48 +1,203 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
+import unittest
+import numpy as np
 from numpy.testing import assert_allclose, assert_approx_equal
+
 from UliEngineering.Physics.Density import normalize_density_kg_per_m3, DensityKgPerM3
-import unittest
+from UliEngineering.Units import InvalidUnitInContextException
 
 
 class TestDensityNormalization(unittest.TestCase):
-    def test_normalize_density(self):
-        # Test kg/m^3 normalization (SI unit)
+    def test_si_units(self):
+        """Test SI base units and unicode variants."""
         assert_approx_equal(normalize_density_kg_per_m3("1 kg/m^3"), 1.0)
-        assert_approx_equal(normalize_density_kg_per_m3("1000 kg/m^3"), 1000.0)
         assert_approx_equal(normalize_density_kg_per_m3("1 kg/m3"), 1.0)
-        # Test g/cm^3 to kg/m^3 conversion
+        assert_approx_equal(normalize_density_kg_per_m3("1 kg/m³"), 1.0)
+        assert_approx_equal(normalize_density_kg_per_m3("1000 kg/m^3"), 1000.0)
+        assert_approx_equal(normalize_density_kg_per_m3("2.5 kg/m³"), 2.5)
+
+    def test_chemistry_units(self):
+        """Test common chemistry/lab density units."""
+        # g/cm³ variants
         assert_approx_equal(normalize_density_kg_per_m3("1 g/cm^3"), 1000.0)
         assert_approx_equal(normalize_density_kg_per_m3("2 g/cm^3"), 2000.0)
         assert_approx_equal(normalize_density_kg_per_m3("2.7 g/cm^3"), 2700.0)
-        # Test g/cm3 to kg/m^3 conversion
         assert_approx_equal(normalize_density_kg_per_m3("1 g/cm3"), 1000.0)
-        # Test g/L to kg/m^3 conversion
+        assert_approx_equal(normalize_density_kg_per_m3("1 g/cm³"), 1000.0)
+        # kg/L variants
+        assert_approx_equal(normalize_density_kg_per_m3("1 kg/L"), 1000.0)
+        assert_approx_equal(normalize_density_kg_per_m3("1 kg/l"), 1000.0)
+        assert_approx_equal(normalize_density_kg_per_m3("2.5 kg/L"), 2500.0)
+        # g/mL variants
+        assert_approx_equal(normalize_density_kg_per_m3("1 g/mL"), 1000.0)
+        assert_approx_equal(normalize_density_kg_per_m3("1 g/ml"), 1000.0)
+        # g/L variants
         assert_approx_equal(normalize_density_kg_per_m3("1 g/L"), 1.0)
         assert_approx_equal(normalize_density_kg_per_m3("1000 g/L"), 1000.0)
         assert_approx_equal(normalize_density_kg_per_m3("1 g/l"), 1.0)
 
-    def test_normalize_density_iterables(self):
-        assert_allclose(normalize_density_kg_per_m3(["1 g/cm^3", "2 g/cm^3"]), [1000.0, 2000.0])
-        assert_allclose(normalize_density_kg_per_m3(["1 kg/m^3", "2 g/L"]), [1.0, 2.0])
+    def test_imperial_units(self):
+        """Test imperial density units."""
+        # lb/ft³
+        assert_approx_equal(normalize_density_kg_per_m3("1 lb/ft³"), 16.0184634)
+        assert_approx_equal(normalize_density_kg_per_m3("1 lb/ft3"), 16.0184634)
+        # lb/in³
+        assert_approx_equal(normalize_density_kg_per_m3("1 lb/in³"), 27679.9047)
+        assert_approx_equal(normalize_density_kg_per_m3("1 lb/in3"), 27679.9047)
+        # lb/gal (US)
+        assert_approx_equal(normalize_density_kg_per_m3("1 lb/gal"), 119.826427)
+        # oz/in³
+        assert_approx_equal(normalize_density_kg_per_m3("1 oz/in³"), 1729.994)
+        assert_approx_equal(normalize_density_kg_per_m3("1 oz/in3"), 1729.994)
+
+    def test_metric_ton_units(self):
+        """Test tonne per cubic meter units."""
+        assert_approx_equal(normalize_density_kg_per_m3("1 t/m³"), 1000.0)
+        assert_approx_equal(normalize_density_kg_per_m3("1 t/m^3"), 1000.0)
+        assert_approx_equal(normalize_density_kg_per_m3("1 t/m3"), 1000.0)
+        assert_approx_equal(normalize_density_kg_per_m3("2.5 t/m³"), 2500.0)
+
+    def test_bare_numbers(self):
+        """Test that bare numbers pass through unchanged."""
+        assert_approx_equal(normalize_density_kg_per_m3(1.0), 1.0)
+        assert_approx_equal(normalize_density_kg_per_m3(1000), 1000.0)
+        assert_approx_equal(normalize_density_kg_per_m3(0.5), 0.5)
+
+    def test_numpy_array_input(self):
+        """Test numpy array input."""
+        arr = np.array(["1 g/cm^3", "2 kg/m^3"])
+        result = normalize_density_kg_per_m3(arr)
+        assert_allclose(result, [1000.0, 2.0])
+
+    def test_list_input(self):
+        """Test list input."""
+        result = normalize_density_kg_per_m3(["1 g/cm^3", "2 g/cm^3"])
+        assert_allclose(result, [1000.0, 2000.0])
+        result = normalize_density_kg_per_m3(["1 kg/m^3", "2 g/L"])
+        assert_allclose(result, [1.0, 2.0])
+
+    def test_tuple_input(self):
+        """Test tuple input."""
+        result = normalize_density_kg_per_m3(("1 g/cm^3", "2 kg/m^3"))
+        assert_allclose(result, [1000.0, 2.0])
+
+    def test_bytes_input(self):
+        """Test bytes input."""
+        assert_approx_equal(normalize_density_kg_per_m3(b"1 kg/m^3"), 1.0)
+        assert_approx_equal(normalize_density_kg_per_m3(b"1 g/cm^3"), 1000.0)
+
+    def test_invalid_unit_raises(self):
+        """Test that invalid units raise InvalidUnitInContextException."""
+        with self.assertRaises(InvalidUnitInContextException):
+            normalize_density_kg_per_m3("1 lb/m^3")
+        with self.assertRaises(InvalidUnitInContextException):
+            normalize_density_kg_per_m3("1 g/mm^3")
+
+    def test_missing_numeric_part_raises(self):
+        """Test that missing numeric part raises ValueError."""
+        with self.assertRaises(ValueError):
+            normalize_density_kg_per_m3("kg/m^3")
+
+    def test_none_raises(self):
+        """Test that None raises ValueError."""
+        with self.assertRaises(ValueError):
+            normalize_density_kg_per_m3(None)
 
     def test_type_annotation_exists(self):
-        """Test that the new type annotation is available."""
+        """Test that the type annotation is available."""
         self.assertIsNotNone(DensityKgPerM3)
 
-    def test_density_type_various_units(self):
-        """Test DensityKgPerM3 type with various unit inputs."""
+    def test_comprehensive_unit_cases(self):
+        """Test all supported units in one parameterized block."""
         test_cases = [
+            # SI
             ("1 kg/m^3", 1.0),
             ("1 kg/m3", 1.0),
-            ("1000 kg/m^3", 1000.0),
+            ("1 kg/m³", 1.0),
+            # Chemistry
             ("1 g/cm^3", 1000.0),
-            ("2 g/cm^3", 2000.0),
             ("1 g/cm3", 1000.0),
+            ("1 g/cm³", 1000.0),
+            ("1 kg/L", 1000.0),
+            ("1 kg/l", 1000.0),
+            ("1 g/mL", 1000.0),
+            ("1 g/ml", 1000.0),
             ("1 g/L", 1.0),
-            ("1000 g/L", 1000.0),
+            ("1 g/l", 1.0),
+            # Imperial
+            ("1 lb/ft³", 16.0184634),
+            ("1 lb/ft3", 16.0184634),
+            ("1 lb/in³", 27679.9047),
+            ("1 lb/in3", 27679.9047),
+            ("1 lb/gal", 119.826427),
+            ("1 oz/in³", 1729.994),
+            ("1 oz/in3", 1729.994),
+            # Tonne
+            ("1 t/m³", 1000.0),
+            ("1 t/m^3", 1000.0),
+            ("1 t/m3", 1000.0),
         ]
         for input_val, expected in test_cases:
             with self.subTest(input=input_val):
                 result = normalize_density_kg_per_m3(input_val)
-                assert_approx_equal(result, expected)
+                assert_approx_equal(result, expected)
+
+
+class TestDensityIntegration(unittest.TestCase):
+    """Integration tests for density normalization in downstream functions."""
+
+    def test_cylinder_weight_with_density_units(self):
+        """Test that cylinder weight functions accept density with units."""
+        from UliEngineering.Math.Geometry.Cylinder import (
+            cylinder_weight_by_diameter,
+            cylinder_weight_by_radius,
+            cylinder_weight_by_cross_sectional_area,
+        )
+
+        # radius=1mm, length=1mm, density=2700 kg/m^3 (aluminium)
+        # volume = pi * (1)^2 * 1 = pi mm^3
+        # weight = volume * density = pi * 2700
+        expected = np.pi * 2700.0
+
+        # With SI density unit
+        w = cylinder_weight_by_radius(1.0, 1.0, "2700 kg/m^3")
+        self.assertAlmostEqual(w, expected, delta=0.1)
+
+        # With g/cm^3 (2.7 g/cm^3 = 2700 kg/m^3)
+        w = cylinder_weight_by_radius(1.0, 1.0, "2.7 g/cm^3")
+        self.assertAlmostEqual(w, expected, delta=0.1)
+
+        # With kg/L (2.7 kg/L = 2700 kg/m^3)
+        w = cylinder_weight_by_radius(1.0, 1.0, "2.7 kg/L")
+        self.assertAlmostEqual(w, expected, delta=0.1)
+
+        # diameter=2mm, length=1mm => same volume and weight
+        w = cylinder_weight_by_diameter(2.0, 1.0, "2.7 g/cm^3")
+        self.assertAlmostEqual(w, expected, delta=0.1)
+
+        # cross-sectional area = pi * r^2 = pi mm^2
+        w = cylinder_weight_by_cross_sectional_area(np.pi, 1.0, "2.7 g/cm^3")
+        self.assertAlmostEqual(w, expected, delta=0.1)
+
+    def test_viscosity_functions_with_density_units(self):
+        """Test that viscosity functions accept density with units."""
+        from UliEngineering.Physics.Viscosity import (
+            kinematic_viscosity,
+            reynolds_number,
+        )
+
+        # kinematic_viscosity(0.001 Pa·s, 1000 kg/m³) => 1e-6 m²/s
+        nu = kinematic_viscosity(0.001, "1 g/cm^3")
+        self.assertAlmostEqual(nu, 1e-6, delta=1e-12)
+
+        nu = kinematic_viscosity(0.001, "1 kg/L")
+        self.assertAlmostEqual(nu, 1e-6, delta=1e-12)
+
+        # Reynolds number: Re = rho * v * L / eta
+        Re = reynolds_number("1 g/cm^3", 1.0, 0.1, 0.001)
+        self.assertAlmostEqual(Re, 100000.0, delta=0.1)
+
+
+if __name__ == '__main__':
+    unittest.main()