qnty 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

qnty/quantities/field_vars.py

@@ -8,8 +8,11 @@ Auto-generated by codegen/generators/field_vars.py
 DO NOT EDIT MANUALLY - changes will be overwritten.
 """
 
+from typing import Self
+
 from ..dimensions import field_dims as dim
-from . import field_setter as ts
+from . import field_setter
+from .base_qnty import TypeSafeSetter
 from .field_qnty import FieldQnty
 
 # ===== QUANTITY CLASSES =====
@@ -33,7 +36,7 @@ class AbsorbedDose(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.AbsorbedDoseSetter
+    _setter_class = field_setter.AbsorbedDoseSetter
     _dimension = dim.ABSORBED_DOSE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -56,7 +59,7 @@ class AbsorbedDose(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.AbsorbedDoseSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.AbsorbedDoseSetter':
         """
         Create a setter for this absorbed radiation dose quantity.
         
@@ -71,7 +74,17 @@ class AbsorbedDose(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.AbsorbedDoseSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.AbsorbedDoseSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.AbsorbedDoseSetter(self, value)
     
 
 class Acceleration(FieldQnty):
@@ -92,7 +105,7 @@ class Acceleration(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.AccelerationSetter
+    _setter_class = field_setter.AccelerationSetter
     _dimension = dim.ACCELERATION
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -115,7 +128,7 @@ class Acceleration(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.AccelerationSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.AccelerationSetter':
         """
         Create a setter for this acceleration quantity.
         
@@ -130,7 +143,17 @@ class Acceleration(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.AccelerationSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.AccelerationSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.AccelerationSetter(self, value)
     
 
 class ActivationEnergy(FieldQnty):
@@ -151,7 +174,7 @@ class ActivationEnergy(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ActivationEnergySetter
+    _setter_class = field_setter.ActivationEnergySetter
     _dimension = dim.ACTIVATION_ENERGY
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -174,7 +197,7 @@ class ActivationEnergy(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ActivationEnergySetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ActivationEnergySetter':
         """
         Create a setter for this activation energy quantity.
         
@@ -189,7 +212,17 @@ class ActivationEnergy(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ActivationEnergySetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ActivationEnergySetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ActivationEnergySetter(self, value)
     
 
 class AmountOfSubstance(FieldQnty):
@@ -210,7 +243,7 @@ class AmountOfSubstance(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.AmountOfSubstanceSetter
+    _setter_class = field_setter.AmountOfSubstanceSetter
     _dimension = dim.AMOUNT_OF_SUBSTANCE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -233,7 +266,7 @@ class AmountOfSubstance(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.AmountOfSubstanceSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.AmountOfSubstanceSetter':
         """
         Create a setter for this amount of substance quantity.
         
@@ -248,7 +281,17 @@ class AmountOfSubstance(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.AmountOfSubstanceSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.AmountOfSubstanceSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.AmountOfSubstanceSetter(self, value)
     
 
 class AnglePlane(FieldQnty):
@@ -269,7 +312,7 @@ class AnglePlane(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.AnglePlaneSetter
+    _setter_class = field_setter.AnglePlaneSetter
     _dimension = dim.ANGLE_PLANE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -292,7 +335,7 @@ class AnglePlane(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.AnglePlaneSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.AnglePlaneSetter':
         """
         Create a setter for this angle, plane quantity.
         
@@ -307,7 +350,17 @@ class AnglePlane(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.AnglePlaneSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.AnglePlaneSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.AnglePlaneSetter(self, value)
     
 
 class AngleSolid(FieldQnty):
@@ -328,7 +381,7 @@ class AngleSolid(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.AngleSolidSetter
+    _setter_class = field_setter.AngleSolidSetter
     _dimension = dim.ANGLE_SOLID
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -351,7 +404,7 @@ class AngleSolid(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.AngleSolidSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.AngleSolidSetter':
         """
         Create a setter for this angle, solid quantity.
         
@@ -366,7 +419,17 @@ class AngleSolid(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.AngleSolidSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.AngleSolidSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.AngleSolidSetter(self, value)
     
 
 class AngularAcceleration(FieldQnty):
@@ -387,7 +450,7 @@ class AngularAcceleration(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.AngularAccelerationSetter
+    _setter_class = field_setter.AngularAccelerationSetter
     _dimension = dim.ANGULAR_ACCELERATION
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -410,7 +473,7 @@ class AngularAcceleration(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.AngularAccelerationSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.AngularAccelerationSetter':
         """
         Create a setter for this angular acceleration quantity.
         
@@ -425,7 +488,17 @@ class AngularAcceleration(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.AngularAccelerationSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.AngularAccelerationSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.AngularAccelerationSetter(self, value)
     
 
 class AngularMomentum(FieldQnty):
@@ -446,7 +519,7 @@ class AngularMomentum(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.AngularMomentumSetter
+    _setter_class = field_setter.AngularMomentumSetter
     _dimension = dim.ANGULAR_MOMENTUM
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -469,7 +542,7 @@ class AngularMomentum(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.AngularMomentumSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.AngularMomentumSetter':
         """
         Create a setter for this angular momentum quantity.
         
@@ -484,7 +557,17 @@ class AngularMomentum(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.AngularMomentumSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.AngularMomentumSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.AngularMomentumSetter(self, value)
     
 
 class Area(FieldQnty):
@@ -505,7 +588,7 @@ class Area(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.AreaSetter
+    _setter_class = field_setter.AreaSetter
     _dimension = dim.AREA
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -528,7 +611,7 @@ class Area(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.AreaSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.AreaSetter':
         """
         Create a setter for this area quantity.
         
@@ -543,7 +626,17 @@ class Area(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.AreaSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.AreaSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.AreaSetter(self, value)
     
 
 class AreaPerUnitVolume(FieldQnty):
@@ -564,7 +657,7 @@ class AreaPerUnitVolume(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.AreaPerUnitVolumeSetter
+    _setter_class = field_setter.AreaPerUnitVolumeSetter
     _dimension = dim.AREA_PER_UNIT_VOLUME
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -587,7 +680,7 @@ class AreaPerUnitVolume(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.AreaPerUnitVolumeSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.AreaPerUnitVolumeSetter':
         """
         Create a setter for this area per unit volume quantity.
         
@@ -602,7 +695,17 @@ class AreaPerUnitVolume(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.AreaPerUnitVolumeSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.AreaPerUnitVolumeSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.AreaPerUnitVolumeSetter(self, value)
     
 
 class AtomicWeight(FieldQnty):
@@ -623,7 +726,7 @@ class AtomicWeight(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.AtomicWeightSetter
+    _setter_class = field_setter.AtomicWeightSetter
     _dimension = dim.ATOMIC_WEIGHT
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -646,7 +749,7 @@ class AtomicWeight(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.AtomicWeightSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.AtomicWeightSetter':
         """
         Create a setter for this atomic weight quantity.
         
@@ -661,7 +764,17 @@ class AtomicWeight(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.AtomicWeightSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.AtomicWeightSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.AtomicWeightSetter(self, value)
     
 
 class Concentration(FieldQnty):
@@ -682,7 +795,7 @@ class Concentration(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ConcentrationSetter
+    _setter_class = field_setter.ConcentrationSetter
     _dimension = dim.CONCENTRATION
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -705,7 +818,7 @@ class Concentration(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ConcentrationSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ConcentrationSetter':
         """
         Create a setter for this concentration quantity.
         
@@ -720,7 +833,17 @@ class Concentration(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ConcentrationSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ConcentrationSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ConcentrationSetter(self, value)
     
 
 class Dimensionless(FieldQnty):
@@ -739,7 +862,7 @@ class Dimensionless(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.DimensionlessSetter
+    _setter_class = field_setter.DimensionlessSetter
     _dimension = dim.DIMENSIONLESS
 
     def __init__(self, name_or_value: str | int | float, name: str | None = None, is_known: bool = True):
@@ -759,40 +882,32 @@ class Dimensionless(FieldQnty):
             super().__init__(name_or_value, name, is_known=is_known)
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.DimensionlessSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.DimensionlessSetter':
         """
         Create a setter for this dimensionless quantity.
         
         Args:
             value: The numeric value to set
-            unit: Optional unit string (for direct setting)
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
-            DimensionlessSetter: A setter with unit properties like .dimensionless
+            DimensionlessSetter: A setter with unit properties like .meters, .inches, etc.
         
         Example:
-            >>> factor = Dimensionless("factor")
-            >>> factor.set(2.5).dimensionless  # Sets to 2.5
-            >>> factor.set(2.5, "dimensionless")  # Direct setting
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
         """
         if unit is not None:
             # Direct setting with unit
-            setter = ts.DimensionlessSetter(self, value)
+            setter = field_setter.DimensionlessSetter(self, value)
             # Get the unit property and call it to set the value
             if hasattr(setter, unit):
                 getattr(setter, unit)
             else:
-                # Try common aliases
-                unit_aliases = {
-                    "dimensionless": "dimensionless", "": "dimensionless"
-                }
-                if unit in unit_aliases and hasattr(setter, unit_aliases[unit]):
-                    getattr(setter, unit_aliases[unit])
-                else:
-                    raise ValueError(f"Unknown unit: {unit}")
-            return self  # Return the variable itself for consistency
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
         else:
-            return ts.DimensionlessSetter(self, value)
+            return field_setter.DimensionlessSetter(self, value)
     
 
 class DynamicFluidity(FieldQnty):
@@ -813,7 +928,7 @@ class DynamicFluidity(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.DynamicFluiditySetter
+    _setter_class = field_setter.DynamicFluiditySetter
     _dimension = dim.DYNAMIC_FLUIDITY
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -836,7 +951,7 @@ class DynamicFluidity(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.DynamicFluiditySetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.DynamicFluiditySetter':
         """
         Create a setter for this dynamic fluidity quantity.
         
@@ -851,7 +966,17 @@ class DynamicFluidity(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.DynamicFluiditySetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.DynamicFluiditySetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.DynamicFluiditySetter(self, value)
     
 
 class ElectricCapacitance(FieldQnty):
@@ -872,7 +997,7 @@ class ElectricCapacitance(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ElectricCapacitanceSetter
+    _setter_class = field_setter.ElectricCapacitanceSetter
     _dimension = dim.ELECTRIC_CAPACITANCE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -895,7 +1020,7 @@ class ElectricCapacitance(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ElectricCapacitanceSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ElectricCapacitanceSetter':
         """
         Create a setter for this electric capacitance quantity.
         
@@ -910,7 +1035,17 @@ class ElectricCapacitance(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ElectricCapacitanceSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ElectricCapacitanceSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ElectricCapacitanceSetter(self, value)
     
 
 class ElectricCharge(FieldQnty):
@@ -931,7 +1066,7 @@ class ElectricCharge(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ElectricChargeSetter
+    _setter_class = field_setter.ElectricChargeSetter
     _dimension = dim.ELECTRIC_CHARGE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -954,7 +1089,7 @@ class ElectricCharge(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ElectricChargeSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ElectricChargeSetter':
         """
         Create a setter for this electric charge quantity.
         
@@ -969,7 +1104,17 @@ class ElectricCharge(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ElectricChargeSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ElectricChargeSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ElectricChargeSetter(self, value)
     
 
 class ElectricCurrentIntensity(FieldQnty):
@@ -990,7 +1135,7 @@ class ElectricCurrentIntensity(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ElectricCurrentIntensitySetter
+    _setter_class = field_setter.ElectricCurrentIntensitySetter
     _dimension = dim.ELECTRIC_CURRENT_INTENSITY
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -1013,7 +1158,7 @@ class ElectricCurrentIntensity(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ElectricCurrentIntensitySetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ElectricCurrentIntensitySetter':
         """
         Create a setter for this electric current intensity quantity.
         
@@ -1028,7 +1173,17 @@ class ElectricCurrentIntensity(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ElectricCurrentIntensitySetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ElectricCurrentIntensitySetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ElectricCurrentIntensitySetter(self, value)
     
 
 class ElectricDipoleMoment(FieldQnty):
@@ -1049,7 +1204,7 @@ class ElectricDipoleMoment(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ElectricDipoleMomentSetter
+    _setter_class = field_setter.ElectricDipoleMomentSetter
     _dimension = dim.ELECTRIC_DIPOLE_MOMENT
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -1072,7 +1227,7 @@ class ElectricDipoleMoment(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ElectricDipoleMomentSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ElectricDipoleMomentSetter':
         """
         Create a setter for this electric dipole moment quantity.
         
@@ -1087,7 +1242,17 @@ class ElectricDipoleMoment(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ElectricDipoleMomentSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ElectricDipoleMomentSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ElectricDipoleMomentSetter(self, value)
     
 
 class ElectricFieldStrength(FieldQnty):
@@ -1108,7 +1273,7 @@ class ElectricFieldStrength(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ElectricFieldStrengthSetter
+    _setter_class = field_setter.ElectricFieldStrengthSetter
     _dimension = dim.ELECTRIC_FIELD_STRENGTH
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -1131,7 +1296,7 @@ class ElectricFieldStrength(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ElectricFieldStrengthSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ElectricFieldStrengthSetter':
         """
         Create a setter for this electric field strength quantity.
         
@@ -1146,7 +1311,17 @@ class ElectricFieldStrength(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ElectricFieldStrengthSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ElectricFieldStrengthSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ElectricFieldStrengthSetter(self, value)
     
 
 class ElectricInductance(FieldQnty):
@@ -1167,7 +1342,7 @@ class ElectricInductance(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ElectricInductanceSetter
+    _setter_class = field_setter.ElectricInductanceSetter
     _dimension = dim.ELECTRIC_INDUCTANCE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -1190,7 +1365,7 @@ class ElectricInductance(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ElectricInductanceSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ElectricInductanceSetter':
         """
         Create a setter for this electric inductance quantity.
         
@@ -1205,7 +1380,17 @@ class ElectricInductance(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ElectricInductanceSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ElectricInductanceSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ElectricInductanceSetter(self, value)
     
 
 class ElectricPotential(FieldQnty):
@@ -1226,7 +1411,7 @@ class ElectricPotential(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ElectricPotentialSetter
+    _setter_class = field_setter.ElectricPotentialSetter
     _dimension = dim.ELECTRIC_POTENTIAL
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -1249,7 +1434,7 @@ class ElectricPotential(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ElectricPotentialSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ElectricPotentialSetter':
         """
         Create a setter for this electric potential quantity.
         
@@ -1264,7 +1449,17 @@ class ElectricPotential(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ElectricPotentialSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ElectricPotentialSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ElectricPotentialSetter(self, value)
     
 
 class ElectricResistance(FieldQnty):
@@ -1285,7 +1480,7 @@ class ElectricResistance(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ElectricResistanceSetter
+    _setter_class = field_setter.ElectricResistanceSetter
     _dimension = dim.ELECTRIC_RESISTANCE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -1308,7 +1503,7 @@ class ElectricResistance(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ElectricResistanceSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ElectricResistanceSetter':
         """
         Create a setter for this electric resistance quantity.
         
@@ -1323,7 +1518,17 @@ class ElectricResistance(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ElectricResistanceSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ElectricResistanceSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ElectricResistanceSetter(self, value)
     
 
 class ElectricalConductance(FieldQnty):
@@ -1344,7 +1549,7 @@ class ElectricalConductance(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ElectricalConductanceSetter
+    _setter_class = field_setter.ElectricalConductanceSetter
     _dimension = dim.ELECTRICAL_CONDUCTANCE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -1367,7 +1572,7 @@ class ElectricalConductance(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ElectricalConductanceSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ElectricalConductanceSetter':
         """
         Create a setter for this electrical conductance quantity.
         
@@ -1382,7 +1587,17 @@ class ElectricalConductance(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ElectricalConductanceSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ElectricalConductanceSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ElectricalConductanceSetter(self, value)
     
 
 class ElectricalPermittivity(FieldQnty):
@@ -1403,7 +1618,7 @@ class ElectricalPermittivity(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ElectricalPermittivitySetter
+    _setter_class = field_setter.ElectricalPermittivitySetter
     _dimension = dim.ELECTRICAL_PERMITTIVITY
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -1426,7 +1641,7 @@ class ElectricalPermittivity(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ElectricalPermittivitySetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ElectricalPermittivitySetter':
         """
         Create a setter for this electrical permittivity quantity.
         
@@ -1441,7 +1656,17 @@ class ElectricalPermittivity(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ElectricalPermittivitySetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ElectricalPermittivitySetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ElectricalPermittivitySetter(self, value)
     
 
 class ElectricalResistivity(FieldQnty):
@@ -1462,7 +1687,7 @@ class ElectricalResistivity(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ElectricalResistivitySetter
+    _setter_class = field_setter.ElectricalResistivitySetter
     _dimension = dim.ELECTRICAL_RESISTIVITY
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -1485,7 +1710,7 @@ class ElectricalResistivity(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ElectricalResistivitySetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ElectricalResistivitySetter':
         """
         Create a setter for this electrical resistivity quantity.
         
@@ -1500,7 +1725,17 @@ class ElectricalResistivity(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ElectricalResistivitySetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ElectricalResistivitySetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ElectricalResistivitySetter(self, value)
     
 
 class EnergyFlux(FieldQnty):
@@ -1521,7 +1756,7 @@ class EnergyFlux(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.EnergyFluxSetter
+    _setter_class = field_setter.EnergyFluxSetter
     _dimension = dim.ENERGY_FLUX
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -1544,7 +1779,7 @@ class EnergyFlux(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.EnergyFluxSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.EnergyFluxSetter':
         """
         Create a setter for this energy flux quantity.
         
@@ -1559,7 +1794,17 @@ class EnergyFlux(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.EnergyFluxSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.EnergyFluxSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.EnergyFluxSetter(self, value)
     
 
 class EnergyHeatWork(FieldQnty):
@@ -1580,7 +1825,7 @@ class EnergyHeatWork(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.EnergyHeatWorkSetter
+    _setter_class = field_setter.EnergyHeatWorkSetter
     _dimension = dim.ENERGY_HEAT_WORK
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -1603,7 +1848,7 @@ class EnergyHeatWork(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.EnergyHeatWorkSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.EnergyHeatWorkSetter':
         """
         Create a setter for this energy, heat, work quantity.
         
@@ -1618,7 +1863,17 @@ class EnergyHeatWork(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.EnergyHeatWorkSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.EnergyHeatWorkSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.EnergyHeatWorkSetter(self, value)
     
 
 class EnergyPerUnitArea(FieldQnty):
@@ -1639,7 +1894,7 @@ class EnergyPerUnitArea(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.EnergyPerUnitAreaSetter
+    _setter_class = field_setter.EnergyPerUnitAreaSetter
     _dimension = dim.ENERGY_PER_UNIT_AREA
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -1662,7 +1917,7 @@ class EnergyPerUnitArea(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.EnergyPerUnitAreaSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.EnergyPerUnitAreaSetter':
         """
         Create a setter for this energy per unit area quantity.
         
@@ -1677,7 +1932,17 @@ class EnergyPerUnitArea(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.EnergyPerUnitAreaSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.EnergyPerUnitAreaSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.EnergyPerUnitAreaSetter(self, value)
     
 
 class Force(FieldQnty):
@@ -1698,7 +1963,7 @@ class Force(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ForceSetter
+    _setter_class = field_setter.ForceSetter
     _dimension = dim.FORCE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -1721,7 +1986,7 @@ class Force(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ForceSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ForceSetter':
         """
         Create a setter for this force quantity.
         
@@ -1736,7 +2001,17 @@ class Force(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ForceSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ForceSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ForceSetter(self, value)
     
 
 class ForceBody(FieldQnty):
@@ -1757,7 +2032,7 @@ class ForceBody(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ForceBodySetter
+    _setter_class = field_setter.ForceBodySetter
     _dimension = dim.FORCE_BODY
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -1780,7 +2055,7 @@ class ForceBody(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ForceBodySetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ForceBodySetter':
         """
         Create a setter for this force (body) quantity.
         
@@ -1795,7 +2070,17 @@ class ForceBody(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ForceBodySetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ForceBodySetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ForceBodySetter(self, value)
     
 
 class ForcePerUnitMass(FieldQnty):
@@ -1816,7 +2101,7 @@ class ForcePerUnitMass(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ForcePerUnitMassSetter
+    _setter_class = field_setter.ForcePerUnitMassSetter
     _dimension = dim.FORCE_PER_UNIT_MASS
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -1839,7 +2124,7 @@ class ForcePerUnitMass(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ForcePerUnitMassSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ForcePerUnitMassSetter':
         """
         Create a setter for this force per unit mass quantity.
         
@@ -1854,7 +2139,17 @@ class ForcePerUnitMass(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ForcePerUnitMassSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ForcePerUnitMassSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ForcePerUnitMassSetter(self, value)
     
 
 class FrequencyVoltageRatio(FieldQnty):
@@ -1875,7 +2170,7 @@ class FrequencyVoltageRatio(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.FrequencyVoltageRatioSetter
+    _setter_class = field_setter.FrequencyVoltageRatioSetter
     _dimension = dim.FREQUENCY_VOLTAGE_RATIO
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -1898,7 +2193,7 @@ class FrequencyVoltageRatio(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.FrequencyVoltageRatioSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.FrequencyVoltageRatioSetter':
         """
         Create a setter for this frequency voltage ratio quantity.
         
@@ -1913,7 +2208,17 @@ class FrequencyVoltageRatio(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.FrequencyVoltageRatioSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.FrequencyVoltageRatioSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.FrequencyVoltageRatioSetter(self, value)
     
 
 class FuelConsumption(FieldQnty):
@@ -1934,7 +2239,7 @@ class FuelConsumption(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.FuelConsumptionSetter
+    _setter_class = field_setter.FuelConsumptionSetter
     _dimension = dim.FUEL_CONSUMPTION
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -1957,7 +2262,7 @@ class FuelConsumption(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.FuelConsumptionSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.FuelConsumptionSetter':
         """
         Create a setter for this fuel consumption quantity.
         
@@ -1972,7 +2277,17 @@ class FuelConsumption(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.FuelConsumptionSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.FuelConsumptionSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.FuelConsumptionSetter(self, value)
     
 
 class HeatOfCombustion(FieldQnty):
@@ -1993,7 +2308,7 @@ class HeatOfCombustion(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.HeatOfCombustionSetter
+    _setter_class = field_setter.HeatOfCombustionSetter
     _dimension = dim.HEAT_OF_COMBUSTION
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -2016,7 +2331,7 @@ class HeatOfCombustion(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.HeatOfCombustionSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.HeatOfCombustionSetter':
         """
         Create a setter for this heat of combustion quantity.
         
@@ -2031,7 +2346,17 @@ class HeatOfCombustion(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.HeatOfCombustionSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.HeatOfCombustionSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.HeatOfCombustionSetter(self, value)
     
 
 class HeatOfFusion(FieldQnty):
@@ -2052,7 +2377,7 @@ class HeatOfFusion(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.HeatOfFusionSetter
+    _setter_class = field_setter.HeatOfFusionSetter
     _dimension = dim.HEAT_OF_FUSION
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -2075,7 +2400,7 @@ class HeatOfFusion(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.HeatOfFusionSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.HeatOfFusionSetter':
         """
         Create a setter for this heat of fusion quantity.
         
@@ -2090,7 +2415,17 @@ class HeatOfFusion(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.HeatOfFusionSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.HeatOfFusionSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.HeatOfFusionSetter(self, value)
     
 
 class HeatOfVaporization(FieldQnty):
@@ -2111,7 +2446,7 @@ class HeatOfVaporization(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.HeatOfVaporizationSetter
+    _setter_class = field_setter.HeatOfVaporizationSetter
     _dimension = dim.HEAT_OF_VAPORIZATION
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -2134,7 +2469,7 @@ class HeatOfVaporization(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.HeatOfVaporizationSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.HeatOfVaporizationSetter':
         """
         Create a setter for this heat of vaporization quantity.
         
@@ -2149,7 +2484,17 @@ class HeatOfVaporization(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.HeatOfVaporizationSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.HeatOfVaporizationSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.HeatOfVaporizationSetter(self, value)
     
 
 class HeatTransferCoefficient(FieldQnty):
@@ -2170,7 +2515,7 @@ class HeatTransferCoefficient(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.HeatTransferCoefficientSetter
+    _setter_class = field_setter.HeatTransferCoefficientSetter
     _dimension = dim.HEAT_TRANSFER_COEFFICIENT
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -2193,7 +2538,7 @@ class HeatTransferCoefficient(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.HeatTransferCoefficientSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.HeatTransferCoefficientSetter':
         """
         Create a setter for this heat transfer coefficient quantity.
         
@@ -2208,7 +2553,17 @@ class HeatTransferCoefficient(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.HeatTransferCoefficientSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.HeatTransferCoefficientSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.HeatTransferCoefficientSetter(self, value)
     
 
 class Illuminance(FieldQnty):
@@ -2229,7 +2584,7 @@ class Illuminance(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.IlluminanceSetter
+    _setter_class = field_setter.IlluminanceSetter
     _dimension = dim.ILLUMINANCE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -2252,7 +2607,7 @@ class Illuminance(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.IlluminanceSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.IlluminanceSetter':
         """
         Create a setter for this illuminance quantity.
         
@@ -2267,7 +2622,17 @@ class Illuminance(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.IlluminanceSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.IlluminanceSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.IlluminanceSetter(self, value)
     
 
 class KineticEnergyOfTurbulence(FieldQnty):
@@ -2288,7 +2653,7 @@ class KineticEnergyOfTurbulence(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.KineticEnergyOfTurbulenceSetter
+    _setter_class = field_setter.KineticEnergyOfTurbulenceSetter
     _dimension = dim.KINETIC_ENERGY_OF_TURBULENCE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -2311,7 +2676,7 @@ class KineticEnergyOfTurbulence(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.KineticEnergyOfTurbulenceSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.KineticEnergyOfTurbulenceSetter':
         """
         Create a setter for this kinetic energy of turbulence quantity.
         
@@ -2326,7 +2691,17 @@ class KineticEnergyOfTurbulence(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.KineticEnergyOfTurbulenceSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.KineticEnergyOfTurbulenceSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.KineticEnergyOfTurbulenceSetter(self, value)
     
 
 class Length(FieldQnty):
@@ -2347,7 +2722,7 @@ class Length(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.LengthSetter
+    _setter_class = field_setter.LengthSetter
     _dimension = dim.LENGTH
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -2370,13 +2745,13 @@ class Length(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.LengthSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.LengthSetter':
         """
         Create a setter for this length quantity.
         
         Args:
             value: The numeric value to set
-            unit: Optional unit string (for direct setting)
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
             LengthSetter: A setter with unit properties like .meters, .inches, etc.
@@ -2384,30 +2759,18 @@ class Length(FieldQnty):
         Example:
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
-            >>> length.set(100, "inch")  # Direct setting
         """
         if unit is not None:
             # Direct setting with unit
-            setter = ts.LengthSetter(self, value)
+            setter = field_setter.LengthSetter(self, value)
             # Get the unit property and call it to set the value
             if hasattr(setter, unit):
                 getattr(setter, unit)
             else:
-                # Try common aliases
-                unit_aliases = {
-                    "inch": "inch", "inches": "inch", "in": "inch",
-                    "foot": "foot", "feet": "foot", "ft": "foot", 
-                    "meter": "meter", "meters": "meter", "m": "meter",
-                    "millimeter": "millimeter", "millimeters": "millimeter", "mm": "millimeter",
-                    "centimeter": "centimeter", "centimeters": "centimeter", "cm": "centimeter"
-                }
-                if unit in unit_aliases and hasattr(setter, unit_aliases[unit]):
-                    getattr(setter, unit_aliases[unit])
-                else:
-                    raise ValueError(f"Unknown unit: {unit}")
-            return self  # Return the variable itself for consistency
-        else:
-            return ts.LengthSetter(self, value)
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.LengthSetter(self, value)
     
 
 class LinearMassDensity(FieldQnty):
@@ -2428,7 +2791,7 @@ class LinearMassDensity(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.LinearMassDensitySetter
+    _setter_class = field_setter.LinearMassDensitySetter
     _dimension = dim.LINEAR_MASS_DENSITY
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -2451,7 +2814,7 @@ class LinearMassDensity(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.LinearMassDensitySetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.LinearMassDensitySetter':
         """
         Create a setter for this linear mass density quantity.
         
@@ -2466,7 +2829,17 @@ class LinearMassDensity(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.LinearMassDensitySetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.LinearMassDensitySetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.LinearMassDensitySetter(self, value)
     
 
 class LinearMomentum(FieldQnty):
@@ -2487,7 +2860,7 @@ class LinearMomentum(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.LinearMomentumSetter
+    _setter_class = field_setter.LinearMomentumSetter
     _dimension = dim.LINEAR_MOMENTUM
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -2510,7 +2883,7 @@ class LinearMomentum(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.LinearMomentumSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.LinearMomentumSetter':
         """
         Create a setter for this linear momentum quantity.
         
@@ -2525,7 +2898,17 @@ class LinearMomentum(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.LinearMomentumSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.LinearMomentumSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.LinearMomentumSetter(self, value)
     
 
 class LuminanceSelf(FieldQnty):
@@ -2546,7 +2929,7 @@ class LuminanceSelf(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.LuminanceSelfSetter
+    _setter_class = field_setter.LuminanceSelfSetter
     _dimension = dim.LUMINANCE_SELF
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -2569,7 +2952,7 @@ class LuminanceSelf(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.LuminanceSelfSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.LuminanceSelfSetter':
         """
         Create a setter for this luminance (self) quantity.
         
@@ -2584,7 +2967,17 @@ class LuminanceSelf(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.LuminanceSelfSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.LuminanceSelfSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.LuminanceSelfSetter(self, value)
     
 
 class LuminousFlux(FieldQnty):
@@ -2605,7 +2998,7 @@ class LuminousFlux(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.LuminousFluxSetter
+    _setter_class = field_setter.LuminousFluxSetter
     _dimension = dim.LUMINOUS_FLUX
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -2628,7 +3021,7 @@ class LuminousFlux(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.LuminousFluxSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.LuminousFluxSetter':
         """
         Create a setter for this luminous flux quantity.
         
@@ -2643,7 +3036,17 @@ class LuminousFlux(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.LuminousFluxSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.LuminousFluxSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.LuminousFluxSetter(self, value)
     
 
 class LuminousIntensity(FieldQnty):
@@ -2664,7 +3067,7 @@ class LuminousIntensity(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.LuminousIntensitySetter
+    _setter_class = field_setter.LuminousIntensitySetter
     _dimension = dim.LUMINOUS_INTENSITY
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -2687,7 +3090,7 @@ class LuminousIntensity(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.LuminousIntensitySetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.LuminousIntensitySetter':
         """
         Create a setter for this luminous intensity quantity.
         
@@ -2702,7 +3105,17 @@ class LuminousIntensity(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.LuminousIntensitySetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.LuminousIntensitySetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.LuminousIntensitySetter(self, value)
     
 
 class MagneticField(FieldQnty):
@@ -2723,7 +3136,7 @@ class MagneticField(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MagneticFieldSetter
+    _setter_class = field_setter.MagneticFieldSetter
     _dimension = dim.MAGNETIC_FIELD
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -2746,7 +3159,7 @@ class MagneticField(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MagneticFieldSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MagneticFieldSetter':
         """
         Create a setter for this magnetic field quantity.
         
@@ -2761,7 +3174,17 @@ class MagneticField(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MagneticFieldSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MagneticFieldSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MagneticFieldSetter(self, value)
     
 
 class MagneticFlux(FieldQnty):
@@ -2782,7 +3205,7 @@ class MagneticFlux(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MagneticFluxSetter
+    _setter_class = field_setter.MagneticFluxSetter
     _dimension = dim.MAGNETIC_FLUX
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -2805,7 +3228,7 @@ class MagneticFlux(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MagneticFluxSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MagneticFluxSetter':
         """
         Create a setter for this magnetic flux quantity.
         
@@ -2820,7 +3243,17 @@ class MagneticFlux(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MagneticFluxSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MagneticFluxSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MagneticFluxSetter(self, value)
     
 
 class MagneticInductionFieldStrength(FieldQnty):
@@ -2841,7 +3274,7 @@ class MagneticInductionFieldStrength(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MagneticInductionFieldStrengthSetter
+    _setter_class = field_setter.MagneticInductionFieldStrengthSetter
     _dimension = dim.MAGNETIC_INDUCTION_FIELD_STRENGTH
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -2864,7 +3297,7 @@ class MagneticInductionFieldStrength(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MagneticInductionFieldStrengthSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MagneticInductionFieldStrengthSetter':
         """
         Create a setter for this magnetic induction field strength quantity.
         
@@ -2879,7 +3312,17 @@ class MagneticInductionFieldStrength(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MagneticInductionFieldStrengthSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MagneticInductionFieldStrengthSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MagneticInductionFieldStrengthSetter(self, value)
     
 
 class MagneticMoment(FieldQnty):
@@ -2900,7 +3343,7 @@ class MagneticMoment(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MagneticMomentSetter
+    _setter_class = field_setter.MagneticMomentSetter
     _dimension = dim.MAGNETIC_MOMENT
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -2923,7 +3366,7 @@ class MagneticMoment(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MagneticMomentSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MagneticMomentSetter':
         """
         Create a setter for this magnetic moment quantity.
         
@@ -2938,7 +3381,17 @@ class MagneticMoment(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MagneticMomentSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MagneticMomentSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MagneticMomentSetter(self, value)
     
 
 class MagneticPermeability(FieldQnty):
@@ -2959,7 +3412,7 @@ class MagneticPermeability(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MagneticPermeabilitySetter
+    _setter_class = field_setter.MagneticPermeabilitySetter
     _dimension = dim.MAGNETIC_PERMEABILITY
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -2982,7 +3435,7 @@ class MagneticPermeability(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MagneticPermeabilitySetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MagneticPermeabilitySetter':
         """
         Create a setter for this magnetic permeability quantity.
         
@@ -2997,7 +3450,17 @@ class MagneticPermeability(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MagneticPermeabilitySetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MagneticPermeabilitySetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MagneticPermeabilitySetter(self, value)
     
 
 class MagnetomotiveForce(FieldQnty):
@@ -3018,7 +3481,7 @@ class MagnetomotiveForce(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MagnetomotiveForceSetter
+    _setter_class = field_setter.MagnetomotiveForceSetter
     _dimension = dim.MAGNETOMOTIVE_FORCE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -3041,7 +3504,7 @@ class MagnetomotiveForce(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MagnetomotiveForceSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MagnetomotiveForceSetter':
         """
         Create a setter for this magnetomotive force quantity.
         
@@ -3056,7 +3519,17 @@ class MagnetomotiveForce(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MagnetomotiveForceSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MagnetomotiveForceSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MagnetomotiveForceSetter(self, value)
     
 
 class Mass(FieldQnty):
@@ -3077,7 +3550,7 @@ class Mass(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MassSetter
+    _setter_class = field_setter.MassSetter
     _dimension = dim.MASS
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -3100,7 +3573,7 @@ class Mass(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MassSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MassSetter':
         """
         Create a setter for this mass quantity.
         
@@ -3115,7 +3588,17 @@ class Mass(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MassSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MassSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MassSetter(self, value)
     
 
 class MassDensity(FieldQnty):
@@ -3136,7 +3619,7 @@ class MassDensity(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MassDensitySetter
+    _setter_class = field_setter.MassDensitySetter
     _dimension = dim.MASS_DENSITY
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -3159,7 +3642,7 @@ class MassDensity(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MassDensitySetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MassDensitySetter':
         """
         Create a setter for this mass density quantity.
         
@@ -3174,7 +3657,17 @@ class MassDensity(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MassDensitySetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MassDensitySetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MassDensitySetter(self, value)
     
 
 class MassFlowRate(FieldQnty):
@@ -3195,7 +3688,7 @@ class MassFlowRate(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MassFlowRateSetter
+    _setter_class = field_setter.MassFlowRateSetter
     _dimension = dim.MASS_FLOW_RATE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -3218,7 +3711,7 @@ class MassFlowRate(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MassFlowRateSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MassFlowRateSetter':
         """
         Create a setter for this mass flow rate quantity.
         
@@ -3233,7 +3726,17 @@ class MassFlowRate(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MassFlowRateSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MassFlowRateSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MassFlowRateSetter(self, value)
     
 
 class MassFlux(FieldQnty):
@@ -3254,7 +3757,7 @@ class MassFlux(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MassFluxSetter
+    _setter_class = field_setter.MassFluxSetter
     _dimension = dim.MASS_FLUX
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -3277,7 +3780,7 @@ class MassFlux(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MassFluxSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MassFluxSetter':
         """
         Create a setter for this mass flux quantity.
         
@@ -3292,7 +3795,17 @@ class MassFlux(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MassFluxSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MassFluxSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MassFluxSetter(self, value)
     
 
 class MassFractionOfI(FieldQnty):
@@ -3313,7 +3826,7 @@ class MassFractionOfI(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MassFractionOfISetter
+    _setter_class = field_setter.MassFractionOfISetter
     _dimension = dim.MASS_FRACTION_OF_I
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -3336,7 +3849,7 @@ class MassFractionOfI(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MassFractionOfISetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MassFractionOfISetter':
         """
         Create a setter for this mass fraction of "i" quantity.
         
@@ -3351,7 +3864,17 @@ class MassFractionOfI(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MassFractionOfISetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MassFractionOfISetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MassFractionOfISetter(self, value)
     
 
 class MassTransferCoefficient(FieldQnty):
@@ -3372,7 +3895,7 @@ class MassTransferCoefficient(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MassTransferCoefficientSetter
+    _setter_class = field_setter.MassTransferCoefficientSetter
     _dimension = dim.MASS_TRANSFER_COEFFICIENT
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -3395,7 +3918,7 @@ class MassTransferCoefficient(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MassTransferCoefficientSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MassTransferCoefficientSetter':
         """
         Create a setter for this mass transfer coefficient quantity.
         
@@ -3410,7 +3933,17 @@ class MassTransferCoefficient(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MassTransferCoefficientSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MassTransferCoefficientSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MassTransferCoefficientSetter(self, value)
     
 
 class MolalityOfSoluteI(FieldQnty):
@@ -3431,7 +3964,7 @@ class MolalityOfSoluteI(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MolalityOfSoluteISetter
+    _setter_class = field_setter.MolalityOfSoluteISetter
     _dimension = dim.MOLALITY_OF_SOLUTE_I
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -3454,7 +3987,7 @@ class MolalityOfSoluteI(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MolalityOfSoluteISetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MolalityOfSoluteISetter':
         """
         Create a setter for this molality of solute "i" quantity.
         
@@ -3469,7 +4002,17 @@ class MolalityOfSoluteI(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MolalityOfSoluteISetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MolalityOfSoluteISetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MolalityOfSoluteISetter(self, value)
     
 
 class MolarConcentrationByMass(FieldQnty):
@@ -3490,7 +4033,7 @@ class MolarConcentrationByMass(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MolarConcentrationByMassSetter
+    _setter_class = field_setter.MolarConcentrationByMassSetter
     _dimension = dim.MOLAR_CONCENTRATION_BY_MASS
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -3513,7 +4056,7 @@ class MolarConcentrationByMass(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MolarConcentrationByMassSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MolarConcentrationByMassSetter':
         """
         Create a setter for this molar concentration by mass quantity.
         
@@ -3528,7 +4071,17 @@ class MolarConcentrationByMass(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MolarConcentrationByMassSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MolarConcentrationByMassSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MolarConcentrationByMassSetter(self, value)
     
 
 class MolarFlowRate(FieldQnty):
@@ -3549,7 +4102,7 @@ class MolarFlowRate(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MolarFlowRateSetter
+    _setter_class = field_setter.MolarFlowRateSetter
     _dimension = dim.MOLAR_FLOW_RATE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -3572,7 +4125,7 @@ class MolarFlowRate(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MolarFlowRateSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MolarFlowRateSetter':
         """
         Create a setter for this molar flow rate quantity.
         
@@ -3587,7 +4140,17 @@ class MolarFlowRate(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MolarFlowRateSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MolarFlowRateSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MolarFlowRateSetter(self, value)
     
 
 class MolarFlux(FieldQnty):
@@ -3608,7 +4171,7 @@ class MolarFlux(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MolarFluxSetter
+    _setter_class = field_setter.MolarFluxSetter
     _dimension = dim.MOLAR_FLUX
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -3631,7 +4194,7 @@ class MolarFlux(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MolarFluxSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MolarFluxSetter':
         """
         Create a setter for this molar flux quantity.
         
@@ -3646,7 +4209,17 @@ class MolarFlux(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MolarFluxSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MolarFluxSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MolarFluxSetter(self, value)
     
 
 class MolarHeatCapacity(FieldQnty):
@@ -3667,7 +4240,7 @@ class MolarHeatCapacity(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MolarHeatCapacitySetter
+    _setter_class = field_setter.MolarHeatCapacitySetter
     _dimension = dim.MOLAR_HEAT_CAPACITY
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -3690,7 +4263,7 @@ class MolarHeatCapacity(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MolarHeatCapacitySetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MolarHeatCapacitySetter':
         """
         Create a setter for this molar heat capacity quantity.
         
@@ -3705,7 +4278,17 @@ class MolarHeatCapacity(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MolarHeatCapacitySetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MolarHeatCapacitySetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MolarHeatCapacitySetter(self, value)
     
 
 class MolarityOfI(FieldQnty):
@@ -3726,7 +4309,7 @@ class MolarityOfI(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MolarityOfISetter
+    _setter_class = field_setter.MolarityOfISetter
     _dimension = dim.MOLARITY_OF_I
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -3749,7 +4332,7 @@ class MolarityOfI(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MolarityOfISetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MolarityOfISetter':
         """
         Create a setter for this molarity of "i" quantity.
         
@@ -3764,7 +4347,17 @@ class MolarityOfI(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MolarityOfISetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MolarityOfISetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MolarityOfISetter(self, value)
     
 
 class MoleFractionOfI(FieldQnty):
@@ -3785,7 +4378,7 @@ class MoleFractionOfI(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MoleFractionOfISetter
+    _setter_class = field_setter.MoleFractionOfISetter
     _dimension = dim.MOLE_FRACTION_OF_I
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -3808,7 +4401,7 @@ class MoleFractionOfI(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MoleFractionOfISetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MoleFractionOfISetter':
         """
         Create a setter for this mole fraction of "i" quantity.
         
@@ -3823,7 +4416,17 @@ class MoleFractionOfI(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MoleFractionOfISetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MoleFractionOfISetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MoleFractionOfISetter(self, value)
     
 
 class MomentOfInertia(FieldQnty):
@@ -3844,7 +4447,7 @@ class MomentOfInertia(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MomentOfInertiaSetter
+    _setter_class = field_setter.MomentOfInertiaSetter
     _dimension = dim.MOMENT_OF_INERTIA
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -3867,7 +4470,7 @@ class MomentOfInertia(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MomentOfInertiaSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MomentOfInertiaSetter':
         """
         Create a setter for this moment of inertia quantity.
         
@@ -3882,7 +4485,17 @@ class MomentOfInertia(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MomentOfInertiaSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MomentOfInertiaSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MomentOfInertiaSetter(self, value)
     
 
 class MomentumFlowRate(FieldQnty):
@@ -3903,7 +4516,7 @@ class MomentumFlowRate(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MomentumFlowRateSetter
+    _setter_class = field_setter.MomentumFlowRateSetter
     _dimension = dim.MOMENTUM_FLOW_RATE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -3926,7 +4539,7 @@ class MomentumFlowRate(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MomentumFlowRateSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MomentumFlowRateSetter':
         """
         Create a setter for this momentum flow rate quantity.
         
@@ -3941,7 +4554,17 @@ class MomentumFlowRate(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MomentumFlowRateSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MomentumFlowRateSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MomentumFlowRateSetter(self, value)
     
 
 class MomentumFlux(FieldQnty):
@@ -3962,7 +4585,7 @@ class MomentumFlux(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.MomentumFluxSetter
+    _setter_class = field_setter.MomentumFluxSetter
     _dimension = dim.MOMENTUM_FLUX
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -3985,7 +4608,7 @@ class MomentumFlux(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.MomentumFluxSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.MomentumFluxSetter':
         """
         Create a setter for this momentum flux quantity.
         
@@ -4000,7 +4623,17 @@ class MomentumFlux(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.MomentumFluxSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.MomentumFluxSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.MomentumFluxSetter(self, value)
     
 
 class NormalityOfSolution(FieldQnty):
@@ -4021,7 +4654,7 @@ class NormalityOfSolution(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.NormalityOfSolutionSetter
+    _setter_class = field_setter.NormalityOfSolutionSetter
     _dimension = dim.NORMALITY_OF_SOLUTION
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -4044,7 +4677,7 @@ class NormalityOfSolution(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.NormalityOfSolutionSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.NormalityOfSolutionSetter':
         """
         Create a setter for this normality of solution quantity.
         
@@ -4059,7 +4692,17 @@ class NormalityOfSolution(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.NormalityOfSolutionSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.NormalityOfSolutionSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.NormalityOfSolutionSetter(self, value)
     
 
 class ParticleDensity(FieldQnty):
@@ -4080,7 +4723,7 @@ class ParticleDensity(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ParticleDensitySetter
+    _setter_class = field_setter.ParticleDensitySetter
     _dimension = dim.PARTICLE_DENSITY
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -4103,7 +4746,7 @@ class ParticleDensity(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ParticleDensitySetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ParticleDensitySetter':
         """
         Create a setter for this particle density quantity.
         
@@ -4118,7 +4761,17 @@ class ParticleDensity(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ParticleDensitySetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ParticleDensitySetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ParticleDensitySetter(self, value)
     
 
 class Percent(FieldQnty):
@@ -4139,7 +4792,7 @@ class Percent(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.PercentSetter
+    _setter_class = field_setter.PercentSetter
     _dimension = dim.PERCENT
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -4162,7 +4815,7 @@ class Percent(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.PercentSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.PercentSetter':
         """
         Create a setter for this percent quantity.
         
@@ -4177,7 +4830,17 @@ class Percent(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.PercentSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.PercentSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.PercentSetter(self, value)
     
 
 class Permeability(FieldQnty):
@@ -4198,7 +4861,7 @@ class Permeability(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.PermeabilitySetter
+    _setter_class = field_setter.PermeabilitySetter
     _dimension = dim.PERMEABILITY
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -4221,7 +4884,7 @@ class Permeability(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.PermeabilitySetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.PermeabilitySetter':
         """
         Create a setter for this permeability quantity.
         
@@ -4236,7 +4899,17 @@ class Permeability(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.PermeabilitySetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.PermeabilitySetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.PermeabilitySetter(self, value)
     
 
 class PhotonEmissionRate(FieldQnty):
@@ -4257,7 +4930,7 @@ class PhotonEmissionRate(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.PhotonEmissionRateSetter
+    _setter_class = field_setter.PhotonEmissionRateSetter
     _dimension = dim.PHOTON_EMISSION_RATE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -4280,7 +4953,7 @@ class PhotonEmissionRate(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.PhotonEmissionRateSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.PhotonEmissionRateSetter':
         """
         Create a setter for this photon emission rate quantity.
         
@@ -4295,7 +4968,17 @@ class PhotonEmissionRate(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.PhotonEmissionRateSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.PhotonEmissionRateSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.PhotonEmissionRateSetter(self, value)
     
 
 class PowerPerUnitMass(FieldQnty):
@@ -4316,7 +4999,7 @@ class PowerPerUnitMass(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.PowerPerUnitMassSetter
+    _setter_class = field_setter.PowerPerUnitMassSetter
     _dimension = dim.POWER_PER_UNIT_MASS
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -4339,7 +5022,7 @@ class PowerPerUnitMass(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.PowerPerUnitMassSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.PowerPerUnitMassSetter':
         """
         Create a setter for this power per unit mass or specific power quantity.
         
@@ -4354,7 +5037,17 @@ class PowerPerUnitMass(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.PowerPerUnitMassSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.PowerPerUnitMassSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.PowerPerUnitMassSetter(self, value)
     
 
 class PowerPerUnitVolume(FieldQnty):
@@ -4375,7 +5068,7 @@ class PowerPerUnitVolume(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.PowerPerUnitVolumeSetter
+    _setter_class = field_setter.PowerPerUnitVolumeSetter
     _dimension = dim.POWER_PER_UNIT_VOLUME
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -4398,7 +5091,7 @@ class PowerPerUnitVolume(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.PowerPerUnitVolumeSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.PowerPerUnitVolumeSetter':
         """
         Create a setter for this power per unit volume or power density quantity.
         
@@ -4413,7 +5106,17 @@ class PowerPerUnitVolume(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.PowerPerUnitVolumeSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.PowerPerUnitVolumeSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.PowerPerUnitVolumeSetter(self, value)
     
 
 class PowerThermalDuty(FieldQnty):
@@ -4434,7 +5137,7 @@ class PowerThermalDuty(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.PowerThermalDutySetter
+    _setter_class = field_setter.PowerThermalDutySetter
     _dimension = dim.POWER_THERMAL_DUTY
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -4457,7 +5160,7 @@ class PowerThermalDuty(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.PowerThermalDutySetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.PowerThermalDutySetter':
         """
         Create a setter for this power, thermal duty quantity.
         
@@ -4472,7 +5175,17 @@ class PowerThermalDuty(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.PowerThermalDutySetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.PowerThermalDutySetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.PowerThermalDutySetter(self, value)
     
 
 class Pressure(FieldQnty):
@@ -4493,7 +5206,7 @@ class Pressure(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.PressureSetter
+    _setter_class = field_setter.PressureSetter
     _dimension = dim.PRESSURE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -4516,45 +5229,32 @@ class Pressure(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.PressureSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.PressureSetter':
         """
         Create a setter for this pressure quantity.
         
         Args:
             value: The numeric value to set
-            unit: Optional unit string (for direct setting)
+            unit: Optional unit string (for compatibility with base class)
         
         Returns:
-            PressureSetter: A setter with unit properties like .psi, .bar, etc.
+            PressureSetter: A setter with unit properties like .meters, .inches, etc.
         
         Example:
-            >>> pressure = Pressure("system_pressure")
-            >>> pressure.set(100).psi  # Sets to 100 psi
-            >>> pressure.set(100, "psi")  # Direct setting
+            >>> length = Length("beam_length")
+            >>> length.set(100).millimeters  # Sets to 100 mm
         """
         if unit is not None:
             # Direct setting with unit
-            setter = ts.PressureSetter(self, value)
+            setter = field_setter.PressureSetter(self, value)
             # Get the unit property and call it to set the value
             if hasattr(setter, unit):
                 getattr(setter, unit)
             else:
-                # Try common aliases
-                unit_aliases = {
-                    "psi": "psi", "pound_per_square_inch": "psi",
-                    "bar": "bar", "bars": "bar",
-                    "pascal": "pascal", "pascals": "pascal", "pa": "pascal",
-                    "kpa": "kilopascal", "kilopascal": "kilopascal",
-                    "mpa": "megapascal", "megapascal": "megapascal",
-                    "atm": "atmosphere", "atmosphere": "atmosphere"
-                }
-                if unit in unit_aliases and hasattr(setter, unit_aliases[unit]):
-                    getattr(setter, unit_aliases[unit])
-                else:
-                    raise ValueError(f"Unknown unit: {unit}")
-            return self  # Return the variable itself for consistency
-        else:
-            return ts.PressureSetter(self, value)
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.PressureSetter(self, value)
     
 
 class RadiationDoseEquivalent(FieldQnty):
@@ -4575,7 +5275,7 @@ class RadiationDoseEquivalent(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.RadiationDoseEquivalentSetter
+    _setter_class = field_setter.RadiationDoseEquivalentSetter
     _dimension = dim.RADIATION_DOSE_EQUIVALENT
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -4598,7 +5298,7 @@ class RadiationDoseEquivalent(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.RadiationDoseEquivalentSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.RadiationDoseEquivalentSetter':
         """
         Create a setter for this radiation dose equivalent quantity.
         
@@ -4613,7 +5313,17 @@ class RadiationDoseEquivalent(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.RadiationDoseEquivalentSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.RadiationDoseEquivalentSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.RadiationDoseEquivalentSetter(self, value)
     
 
 class RadiationExposure(FieldQnty):
@@ -4634,7 +5344,7 @@ class RadiationExposure(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.RadiationExposureSetter
+    _setter_class = field_setter.RadiationExposureSetter
     _dimension = dim.RADIATION_EXPOSURE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -4657,7 +5367,7 @@ class RadiationExposure(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.RadiationExposureSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.RadiationExposureSetter':
         """
         Create a setter for this radiation exposure quantity.
         
@@ -4672,7 +5382,17 @@ class RadiationExposure(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.RadiationExposureSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.RadiationExposureSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.RadiationExposureSetter(self, value)
     
 
 class Radioactivity(FieldQnty):
@@ -4693,7 +5413,7 @@ class Radioactivity(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.RadioactivitySetter
+    _setter_class = field_setter.RadioactivitySetter
     _dimension = dim.RADIOACTIVITY
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -4716,7 +5436,7 @@ class Radioactivity(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.RadioactivitySetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.RadioactivitySetter':
         """
         Create a setter for this radioactivity quantity.
         
@@ -4731,7 +5451,17 @@ class Radioactivity(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.RadioactivitySetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.RadioactivitySetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.RadioactivitySetter(self, value)
     
 
 class SecondMomentOfArea(FieldQnty):
@@ -4752,7 +5482,7 @@ class SecondMomentOfArea(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.SecondMomentOfAreaSetter
+    _setter_class = field_setter.SecondMomentOfAreaSetter
     _dimension = dim.SECOND_MOMENT_OF_AREA
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -4775,7 +5505,7 @@ class SecondMomentOfArea(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.SecondMomentOfAreaSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.SecondMomentOfAreaSetter':
         """
         Create a setter for this second moment of area quantity.
         
@@ -4790,7 +5520,17 @@ class SecondMomentOfArea(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.SecondMomentOfAreaSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.SecondMomentOfAreaSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.SecondMomentOfAreaSetter(self, value)
     
 
 class SecondRadiationConstantPlanck(FieldQnty):
@@ -4811,7 +5551,7 @@ class SecondRadiationConstantPlanck(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.SecondRadiationConstantPlanckSetter
+    _setter_class = field_setter.SecondRadiationConstantPlanckSetter
     _dimension = dim.SECOND_RADIATION_CONSTANT_PLANCK
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -4834,7 +5574,7 @@ class SecondRadiationConstantPlanck(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.SecondRadiationConstantPlanckSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.SecondRadiationConstantPlanckSetter':
         """
         Create a setter for this second radiation constant (planck) quantity.
         
@@ -4849,7 +5589,17 @@ class SecondRadiationConstantPlanck(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.SecondRadiationConstantPlanckSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.SecondRadiationConstantPlanckSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.SecondRadiationConstantPlanckSetter(self, value)
     
 
 class SpecificEnthalpy(FieldQnty):
@@ -4870,7 +5620,7 @@ class SpecificEnthalpy(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.SpecificEnthalpySetter
+    _setter_class = field_setter.SpecificEnthalpySetter
     _dimension = dim.SPECIFIC_ENTHALPY
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -4893,7 +5643,7 @@ class SpecificEnthalpy(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.SpecificEnthalpySetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.SpecificEnthalpySetter':
         """
         Create a setter for this specific enthalpy quantity.
         
@@ -4908,7 +5658,17 @@ class SpecificEnthalpy(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.SpecificEnthalpySetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.SpecificEnthalpySetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.SpecificEnthalpySetter(self, value)
     
 
 class SpecificGravity(FieldQnty):
@@ -4929,7 +5689,7 @@ class SpecificGravity(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.SpecificGravitySetter
+    _setter_class = field_setter.SpecificGravitySetter
     _dimension = dim.SPECIFIC_GRAVITY
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -4952,7 +5712,7 @@ class SpecificGravity(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.SpecificGravitySetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.SpecificGravitySetter':
         """
         Create a setter for this specific gravity quantity.
         
@@ -4967,7 +5727,17 @@ class SpecificGravity(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.SpecificGravitySetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.SpecificGravitySetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.SpecificGravitySetter(self, value)
     
 
 class SpecificHeatCapacityConstantPressure(FieldQnty):
@@ -4988,7 +5758,7 @@ class SpecificHeatCapacityConstantPressure(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.SpecificHeatCapacityConstantPressureSetter
+    _setter_class = field_setter.SpecificHeatCapacityConstantPressureSetter
     _dimension = dim.SPECIFIC_HEAT_CAPACITY_CONSTANT_PRESSURE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -5011,7 +5781,7 @@ class SpecificHeatCapacityConstantPressure(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.SpecificHeatCapacityConstantPressureSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.SpecificHeatCapacityConstantPressureSetter':
         """
         Create a setter for this specific heat capacity (constant pressure) quantity.
         
@@ -5026,7 +5796,17 @@ class SpecificHeatCapacityConstantPressure(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.SpecificHeatCapacityConstantPressureSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.SpecificHeatCapacityConstantPressureSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.SpecificHeatCapacityConstantPressureSetter(self, value)
     
 
 class SpecificLength(FieldQnty):
@@ -5047,7 +5827,7 @@ class SpecificLength(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.SpecificLengthSetter
+    _setter_class = field_setter.SpecificLengthSetter
     _dimension = dim.SPECIFIC_LENGTH
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -5070,7 +5850,7 @@ class SpecificLength(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.SpecificLengthSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.SpecificLengthSetter':
         """
         Create a setter for this specific length quantity.
         
@@ -5085,7 +5865,17 @@ class SpecificLength(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.SpecificLengthSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.SpecificLengthSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.SpecificLengthSetter(self, value)
     
 
 class SpecificSurface(FieldQnty):
@@ -5106,7 +5896,7 @@ class SpecificSurface(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.SpecificSurfaceSetter
+    _setter_class = field_setter.SpecificSurfaceSetter
     _dimension = dim.SPECIFIC_SURFACE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -5129,7 +5919,7 @@ class SpecificSurface(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.SpecificSurfaceSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.SpecificSurfaceSetter':
         """
         Create a setter for this specific surface quantity.
         
@@ -5144,7 +5934,17 @@ class SpecificSurface(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.SpecificSurfaceSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.SpecificSurfaceSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.SpecificSurfaceSetter(self, value)
     
 
 class SpecificVolume(FieldQnty):
@@ -5165,7 +5965,7 @@ class SpecificVolume(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.SpecificVolumeSetter
+    _setter_class = field_setter.SpecificVolumeSetter
     _dimension = dim.SPECIFIC_VOLUME
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -5188,7 +5988,7 @@ class SpecificVolume(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.SpecificVolumeSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.SpecificVolumeSetter':
         """
         Create a setter for this specific volume quantity.
         
@@ -5203,7 +6003,17 @@ class SpecificVolume(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.SpecificVolumeSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.SpecificVolumeSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.SpecificVolumeSetter(self, value)
     
 
 class Stress(FieldQnty):
@@ -5224,7 +6034,7 @@ class Stress(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.StressSetter
+    _setter_class = field_setter.StressSetter
     _dimension = dim.STRESS
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -5247,7 +6057,7 @@ class Stress(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.StressSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.StressSetter':
         """
         Create a setter for this stress quantity.
         
@@ -5262,7 +6072,17 @@ class Stress(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.StressSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.StressSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.StressSetter(self, value)
     
 
 class SurfaceMassDensity(FieldQnty):
@@ -5283,7 +6103,7 @@ class SurfaceMassDensity(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.SurfaceMassDensitySetter
+    _setter_class = field_setter.SurfaceMassDensitySetter
     _dimension = dim.SURFACE_MASS_DENSITY
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -5306,7 +6126,7 @@ class SurfaceMassDensity(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.SurfaceMassDensitySetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.SurfaceMassDensitySetter':
         """
         Create a setter for this surface mass density quantity.
         
@@ -5321,7 +6141,17 @@ class SurfaceMassDensity(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.SurfaceMassDensitySetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.SurfaceMassDensitySetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.SurfaceMassDensitySetter(self, value)
     
 
 class SurfaceTension(FieldQnty):
@@ -5342,7 +6172,7 @@ class SurfaceTension(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.SurfaceTensionSetter
+    _setter_class = field_setter.SurfaceTensionSetter
     _dimension = dim.SURFACE_TENSION
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -5365,7 +6195,7 @@ class SurfaceTension(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.SurfaceTensionSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.SurfaceTensionSetter':
         """
         Create a setter for this surface tension quantity.
         
@@ -5380,7 +6210,17 @@ class SurfaceTension(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.SurfaceTensionSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.SurfaceTensionSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.SurfaceTensionSetter(self, value)
     
 
 class Temperature(FieldQnty):
@@ -5401,7 +6241,7 @@ class Temperature(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.TemperatureSetter
+    _setter_class = field_setter.TemperatureSetter
     _dimension = dim.TEMPERATURE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -5424,7 +6264,7 @@ class Temperature(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.TemperatureSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.TemperatureSetter':
         """
         Create a setter for this temperature quantity.
         
@@ -5439,7 +6279,17 @@ class Temperature(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.TemperatureSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.TemperatureSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.TemperatureSetter(self, value)
     
 
 class ThermalConductivity(FieldQnty):
@@ -5460,7 +6310,7 @@ class ThermalConductivity(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ThermalConductivitySetter
+    _setter_class = field_setter.ThermalConductivitySetter
     _dimension = dim.THERMAL_CONDUCTIVITY
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -5483,7 +6333,7 @@ class ThermalConductivity(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ThermalConductivitySetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ThermalConductivitySetter':
         """
         Create a setter for this thermal conductivity quantity.
         
@@ -5498,7 +6348,17 @@ class ThermalConductivity(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ThermalConductivitySetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ThermalConductivitySetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ThermalConductivitySetter(self, value)
     
 
 class Time(FieldQnty):
@@ -5519,7 +6379,7 @@ class Time(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.TimeSetter
+    _setter_class = field_setter.TimeSetter
     _dimension = dim.TIME
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -5542,7 +6402,7 @@ class Time(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.TimeSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.TimeSetter':
         """
         Create a setter for this time quantity.
         
@@ -5557,7 +6417,17 @@ class Time(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.TimeSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.TimeSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.TimeSetter(self, value)
     
 
 class Torque(FieldQnty):
@@ -5578,7 +6448,7 @@ class Torque(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.TorqueSetter
+    _setter_class = field_setter.TorqueSetter
     _dimension = dim.TORQUE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -5601,7 +6471,7 @@ class Torque(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.TorqueSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.TorqueSetter':
         """
         Create a setter for this torque quantity.
         
@@ -5616,7 +6486,17 @@ class Torque(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.TorqueSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.TorqueSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.TorqueSetter(self, value)
     
 
 class TurbulenceEnergyDissipationRate(FieldQnty):
@@ -5637,7 +6517,7 @@ class TurbulenceEnergyDissipationRate(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.TurbulenceEnergyDissipationRateSetter
+    _setter_class = field_setter.TurbulenceEnergyDissipationRateSetter
     _dimension = dim.TURBULENCE_ENERGY_DISSIPATION_RATE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -5660,7 +6540,7 @@ class TurbulenceEnergyDissipationRate(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.TurbulenceEnergyDissipationRateSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.TurbulenceEnergyDissipationRateSetter':
         """
         Create a setter for this turbulence energy dissipation rate quantity.
         
@@ -5675,7 +6555,17 @@ class TurbulenceEnergyDissipationRate(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.TurbulenceEnergyDissipationRateSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.TurbulenceEnergyDissipationRateSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.TurbulenceEnergyDissipationRateSetter(self, value)
     
 
 class VelocityAngular(FieldQnty):
@@ -5696,7 +6586,7 @@ class VelocityAngular(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.VelocityAngularSetter
+    _setter_class = field_setter.VelocityAngularSetter
     _dimension = dim.VELOCITY_ANGULAR
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -5719,7 +6609,7 @@ class VelocityAngular(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.VelocityAngularSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.VelocityAngularSetter':
         """
         Create a setter for this velocity, angular quantity.
         
@@ -5734,7 +6624,17 @@ class VelocityAngular(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.VelocityAngularSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.VelocityAngularSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.VelocityAngularSetter(self, value)
     
 
 class VelocityLinear(FieldQnty):
@@ -5755,7 +6655,7 @@ class VelocityLinear(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.VelocityLinearSetter
+    _setter_class = field_setter.VelocityLinearSetter
     _dimension = dim.VELOCITY_LINEAR
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -5778,7 +6678,7 @@ class VelocityLinear(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.VelocityLinearSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.VelocityLinearSetter':
         """
         Create a setter for this velocity, linear quantity.
         
@@ -5793,7 +6693,17 @@ class VelocityLinear(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.VelocityLinearSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.VelocityLinearSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.VelocityLinearSetter(self, value)
     
 
 class ViscosityDynamic(FieldQnty):
@@ -5814,7 +6724,7 @@ class ViscosityDynamic(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ViscosityDynamicSetter
+    _setter_class = field_setter.ViscosityDynamicSetter
     _dimension = dim.VISCOSITY_DYNAMIC
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -5837,7 +6747,7 @@ class ViscosityDynamic(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ViscosityDynamicSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ViscosityDynamicSetter':
         """
         Create a setter for this viscosity, dynamic quantity.
         
@@ -5852,7 +6762,17 @@ class ViscosityDynamic(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ViscosityDynamicSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ViscosityDynamicSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ViscosityDynamicSetter(self, value)
     
 
 class ViscosityKinematic(FieldQnty):
@@ -5873,7 +6793,7 @@ class ViscosityKinematic(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.ViscosityKinematicSetter
+    _setter_class = field_setter.ViscosityKinematicSetter
     _dimension = dim.VISCOSITY_KINEMATIC
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -5896,7 +6816,7 @@ class ViscosityKinematic(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.ViscosityKinematicSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.ViscosityKinematicSetter':
         """
         Create a setter for this viscosity, kinematic quantity.
         
@@ -5911,7 +6831,17 @@ class ViscosityKinematic(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.ViscosityKinematicSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.ViscosityKinematicSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.ViscosityKinematicSetter(self, value)
     
 
 class Volume(FieldQnty):
@@ -5932,7 +6862,7 @@ class Volume(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.VolumeSetter
+    _setter_class = field_setter.VolumeSetter
     _dimension = dim.VOLUME
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -5955,7 +6885,7 @@ class Volume(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.VolumeSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.VolumeSetter':
         """
         Create a setter for this volume quantity.
         
@@ -5970,7 +6900,17 @@ class Volume(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.VolumeSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.VolumeSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.VolumeSetter(self, value)
     
 
 class VolumeFractionOfI(FieldQnty):
@@ -5991,7 +6931,7 @@ class VolumeFractionOfI(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.VolumeFractionOfISetter
+    _setter_class = field_setter.VolumeFractionOfISetter
     _dimension = dim.VOLUME_FRACTION_OF_I
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -6014,7 +6954,7 @@ class VolumeFractionOfI(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.VolumeFractionOfISetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.VolumeFractionOfISetter':
         """
         Create a setter for this volume fraction of "i" quantity.
         
@@ -6029,7 +6969,17 @@ class VolumeFractionOfI(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.VolumeFractionOfISetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.VolumeFractionOfISetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.VolumeFractionOfISetter(self, value)
     
 
 class VolumetricCalorificHeatingValue(FieldQnty):
@@ -6050,7 +7000,7 @@ class VolumetricCalorificHeatingValue(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.VolumetricCalorificHeatingValueSetter
+    _setter_class = field_setter.VolumetricCalorificHeatingValueSetter
     _dimension = dim.VOLUMETRIC_CALORIFIC_HEATING_VALUE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -6073,7 +7023,7 @@ class VolumetricCalorificHeatingValue(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.VolumetricCalorificHeatingValueSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.VolumetricCalorificHeatingValueSetter':
         """
         Create a setter for this volumetric calorific (heating) value quantity.
         
@@ -6088,7 +7038,17 @@ class VolumetricCalorificHeatingValue(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.VolumetricCalorificHeatingValueSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.VolumetricCalorificHeatingValueSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.VolumetricCalorificHeatingValueSetter(self, value)
     
 
 class VolumetricCoefficientOfExpansion(FieldQnty):
@@ -6109,7 +7069,7 @@ class VolumetricCoefficientOfExpansion(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.VolumetricCoefficientOfExpansionSetter
+    _setter_class = field_setter.VolumetricCoefficientOfExpansionSetter
     _dimension = dim.VOLUMETRIC_COEFFICIENT_OF_EXPANSION
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -6132,7 +7092,7 @@ class VolumetricCoefficientOfExpansion(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.VolumetricCoefficientOfExpansionSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.VolumetricCoefficientOfExpansionSetter':
         """
         Create a setter for this volumetric coefficient of expansion quantity.
         
@@ -6147,7 +7107,17 @@ class VolumetricCoefficientOfExpansion(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.VolumetricCoefficientOfExpansionSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.VolumetricCoefficientOfExpansionSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.VolumetricCoefficientOfExpansionSetter(self, value)
     
 
 class VolumetricFlowRate(FieldQnty):
@@ -6168,7 +7138,7 @@ class VolumetricFlowRate(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.VolumetricFlowRateSetter
+    _setter_class = field_setter.VolumetricFlowRateSetter
     _dimension = dim.VOLUMETRIC_FLOW_RATE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -6191,7 +7161,7 @@ class VolumetricFlowRate(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.VolumetricFlowRateSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.VolumetricFlowRateSetter':
         """
         Create a setter for this volumetric flow rate quantity.
         
@@ -6206,7 +7176,17 @@ class VolumetricFlowRate(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.VolumetricFlowRateSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.VolumetricFlowRateSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.VolumetricFlowRateSetter(self, value)
     
 
 class VolumetricFlux(FieldQnty):
@@ -6227,7 +7207,7 @@ class VolumetricFlux(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.VolumetricFluxSetter
+    _setter_class = field_setter.VolumetricFluxSetter
     _dimension = dim.VOLUMETRIC_FLUX
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -6250,7 +7230,7 @@ class VolumetricFlux(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.VolumetricFluxSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.VolumetricFluxSetter':
         """
         Create a setter for this volumetric flux quantity.
         
@@ -6265,7 +7245,17 @@ class VolumetricFlux(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.VolumetricFluxSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.VolumetricFluxSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.VolumetricFluxSetter(self, value)
     
 
 class VolumetricMassFlowRate(FieldQnty):
@@ -6286,7 +7276,7 @@ class VolumetricMassFlowRate(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.VolumetricMassFlowRateSetter
+    _setter_class = field_setter.VolumetricMassFlowRateSetter
     _dimension = dim.VOLUMETRIC_MASS_FLOW_RATE
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -6309,7 +7299,7 @@ class VolumetricMassFlowRate(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.VolumetricMassFlowRateSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.VolumetricMassFlowRateSetter':
         """
         Create a setter for this volumetric mass flow rate quantity.
         
@@ -6324,7 +7314,17 @@ class VolumetricMassFlowRate(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.VolumetricMassFlowRateSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.VolumetricMassFlowRateSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.VolumetricMassFlowRateSetter(self, value)
     
 
 class Wavenumber(FieldQnty):
@@ -6345,7 +7345,7 @@ class Wavenumber(FieldQnty):
     """
 
     __slots__ = ()
-    _setter_class = ts.WavenumberSetter
+    _setter_class = field_setter.WavenumberSetter
     _dimension = dim.WAVENUMBER
 
     def __init__(self, name_or_value: str | int | float, unit: str | None = None, name: str | None = None, is_known: bool = True):
@@ -6368,7 +7368,7 @@ class Wavenumber(FieldQnty):
             raise ValueError("Must provide either just name (unknown) or value, unit, and name (known)")
         self.set_arithmetic_mode('expression')  # Default expression mode for backward compatibility
     
-    def set(self, value: float, unit: str | None = None) -> ts.WavenumberSetter:
+    def set(self, value: float, unit: str | None = None) -> 'Self | field_setter.WavenumberSetter':
         """
         Create a setter for this wavenumber quantity.
         
@@ -6383,6 +7383,16 @@ class Wavenumber(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.WavenumberSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            setter = field_setter.WavenumberSetter(self, value)
+            # Get the unit property and call it to set the value
+            if hasattr(setter, unit):
+                getattr(setter, unit)
+            else:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.WavenumberSetter(self, value)