qnty 0.1.0__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,7 +882,7 @@ 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.
         
@@ -774,7 +897,17 @@ class Dimensionless(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.DimensionlessSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            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:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.DimensionlessSetter(self, value)
     
 
 class DynamicFluidity(FieldQnty):
@@ -795,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):
@@ -818,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.
         
@@ -833,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):
@@ -854,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):
@@ -877,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.
         
@@ -892,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):
@@ -913,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):
@@ -936,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.
         
@@ -951,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):
@@ -972,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):
@@ -995,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.
         
@@ -1010,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):
@@ -1031,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):
@@ -1054,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.
         
@@ -1069,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):
@@ -1090,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):
@@ -1113,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.
         
@@ -1128,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):
@@ -1149,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):
@@ -1172,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.
         
@@ -1187,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):
@@ -1208,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):
@@ -1231,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.
         
@@ -1246,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):
@@ -1267,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):
@@ -1290,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.
         
@@ -1305,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):
@@ -1326,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):
@@ -1349,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.
         
@@ -1364,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):
@@ -1385,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):
@@ -1408,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.
         
@@ -1423,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):
@@ -1444,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):
@@ -1467,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.
         
@@ -1482,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):
@@ -1503,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):
@@ -1526,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.
         
@@ -1541,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):
@@ -1562,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):
@@ -1585,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.
         
@@ -1600,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):
@@ -1621,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):
@@ -1644,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.
         
@@ -1659,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):
@@ -1680,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):
@@ -1703,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.
         
@@ -1718,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):
@@ -1739,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):
@@ -1762,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.
         
@@ -1777,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):
@@ -1798,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):
@@ -1821,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.
         
@@ -1836,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):
@@ -1857,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):
@@ -1880,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.
         
@@ -1895,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):
@@ -1916,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):
@@ -1939,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.
         
@@ -1954,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):
@@ -1975,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):
@@ -1998,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.
         
@@ -2013,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):
@@ -2034,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):
@@ -2057,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.
         
@@ -2072,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):
@@ -2093,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):
@@ -2116,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.
         
@@ -2131,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):
@@ -2152,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):
@@ -2175,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.
         
@@ -2190,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):
@@ -2211,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):
@@ -2234,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.
         
@@ -2249,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):
@@ -2270,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):
@@ -2293,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.
         
@@ -2308,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):
@@ -2329,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):
@@ -2352,7 +2745,7 @@ 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.
         
@@ -2367,7 +2760,17 @@ class Length(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.LengthSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            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:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.LengthSetter(self, value)
     
 
 class LinearMassDensity(FieldQnty):
@@ -2388,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):
@@ -2411,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.
         
@@ -2426,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):
@@ -2447,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):
@@ -2470,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.
         
@@ -2485,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):
@@ -2506,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):
@@ -2529,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.
         
@@ -2544,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):
@@ -2565,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):
@@ -2588,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.
         
@@ -2603,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):
@@ -2624,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):
@@ -2647,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.
         
@@ -2662,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):
@@ -2683,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):
@@ -2706,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.
         
@@ -2721,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):
@@ -2742,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):
@@ -2765,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.
         
@@ -2780,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):
@@ -2801,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):
@@ -2824,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.
         
@@ -2839,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):
@@ -2860,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):
@@ -2883,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.
         
@@ -2898,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):
@@ -2919,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):
@@ -2942,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.
         
@@ -2957,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):
@@ -2978,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):
@@ -3001,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.
         
@@ -3016,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):
@@ -3037,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):
@@ -3060,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.
         
@@ -3075,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):
@@ -3096,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):
@@ -3119,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.
         
@@ -3134,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):
@@ -3155,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):
@@ -3178,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.
         
@@ -3193,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):
@@ -3214,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):
@@ -3237,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.
         
@@ -3252,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):
@@ -3273,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):
@@ -3296,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.
         
@@ -3311,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):
@@ -3332,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):
@@ -3355,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.
         
@@ -3370,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):
@@ -3391,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):
@@ -3414,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.
         
@@ -3429,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):
@@ -3450,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):
@@ -3473,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.
         
@@ -3488,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):
@@ -3509,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):
@@ -3532,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.
         
@@ -3547,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):
@@ -3568,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):
@@ -3591,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.
         
@@ -3606,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):
@@ -3627,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):
@@ -3650,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.
         
@@ -3665,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):
@@ -3686,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):
@@ -3709,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.
         
@@ -3724,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):
@@ -3745,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):
@@ -3768,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.
         
@@ -3783,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):
@@ -3804,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):
@@ -3827,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.
         
@@ -3842,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):
@@ -3863,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):
@@ -3886,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.
         
@@ -3901,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):
@@ -3922,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):
@@ -3945,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.
         
@@ -3960,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):
@@ -3981,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):
@@ -4004,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.
         
@@ -4019,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):
@@ -4040,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):
@@ -4063,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.
         
@@ -4078,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):
@@ -4099,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):
@@ -4122,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.
         
@@ -4137,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):
@@ -4158,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):
@@ -4181,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.
         
@@ -4196,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):
@@ -4217,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):
@@ -4240,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.
         
@@ -4255,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):
@@ -4276,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):
@@ -4299,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.
         
@@ -4314,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):
@@ -4335,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):
@@ -4358,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.
         
@@ -4373,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):
@@ -4394,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):
@@ -4417,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.
         
@@ -4432,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):
@@ -4453,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):
@@ -4476,7 +5229,7 @@ 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.
         
@@ -4491,7 +5244,17 @@ class Pressure(FieldQnty):
             >>> length = Length("beam_length")
             >>> length.set(100).millimeters  # Sets to 100 mm
         """
-        return ts.PressureSetter(self, value)
+        if unit is not None:
+            # Direct setting with unit
+            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:
+                raise ValueError(f"Unknown unit: {unit}")
+            return self
+        else:
+            return field_setter.PressureSetter(self, value)
     
 
 class RadiationDoseEquivalent(FieldQnty):
@@ -4512,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):
@@ -4535,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.
         
@@ -4550,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):
@@ -4571,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):
@@ -4594,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.
         
@@ -4609,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):
@@ -4630,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):
@@ -4653,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.
         
@@ -4668,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):
@@ -4689,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):
@@ -4712,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.
         
@@ -4727,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):
@@ -4748,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):
@@ -4771,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.
         
@@ -4786,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):
@@ -4807,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):
@@ -4830,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.
         
@@ -4845,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):
@@ -4866,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):
@@ -4889,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.
         
@@ -4904,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):
@@ -4925,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):
@@ -4948,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.
         
@@ -4963,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):
@@ -4984,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):
@@ -5007,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.
         
@@ -5022,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):
@@ -5043,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):
@@ -5066,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.
         
@@ -5081,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):
@@ -5102,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):
@@ -5125,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.
         
@@ -5140,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):
@@ -5161,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):
@@ -5184,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.
         
@@ -5199,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):
@@ -5220,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):
@@ -5243,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.
         
@@ -5258,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):
@@ -5279,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):
@@ -5302,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.
         
@@ -5317,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):
@@ -5338,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):
@@ -5361,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.
         
@@ -5376,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):
@@ -5397,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):
@@ -5420,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.
         
@@ -5435,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):
@@ -5456,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):
@@ -5479,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.
         
@@ -5494,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):
@@ -5515,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):
@@ -5538,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.
         
@@ -5553,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):
@@ -5574,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):
@@ -5597,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.
         
@@ -5612,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):
@@ -5633,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):
@@ -5656,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.
         
@@ -5671,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):
@@ -5692,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):
@@ -5715,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.
         
@@ -5730,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):
@@ -5751,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):
@@ -5774,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.
         
@@ -5789,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):
@@ -5810,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):
@@ -5833,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.
         
@@ -5848,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):
@@ -5869,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):
@@ -5892,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.
         
@@ -5907,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):
@@ -5928,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):
@@ -5951,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.
         
@@ -5966,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):
@@ -5987,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):
@@ -6010,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.
         
@@ -6025,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):
@@ -6046,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):
@@ -6069,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.
         
@@ -6084,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):
@@ -6105,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):
@@ -6128,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.
         
@@ -6143,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):
@@ -6164,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):
@@ -6187,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.
         
@@ -6202,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):
@@ -6223,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):
@@ -6246,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.
         
@@ -6261,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):
@@ -6282,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):
@@ -6305,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.
         
@@ -6320,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)