agx-openplx 0.15.22__cp39-cp39-win_amd64.whl → 0.16.0__cp39-cp39-win_amd64.whl

openplx/DriveTrain.py

@@ -6950,27 +6950,27 @@ class DriveTrain_ViscousGear_Vector(object):
 # Register DriveTrain_ViscousGear_Vector in _DriveTrainSwig:
 _DriveTrainSwig.DriveTrain_ViscousGear_Vector_swigregister(DriveTrain_ViscousGear_Vector)
 
-class Actuator(openplx.Core.Object):
+class DriveTrain_Actuator(openplx.Core.Object):
     r"""Proxy of C++ openplx::DriveTrain::Actuator class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Actuator self) -> Actuator"""
-        _DriveTrainSwig.Actuator_swiginit(self, _DriveTrainSwig.new_Actuator())
+        r"""__init__(DriveTrain_Actuator self) -> DriveTrain_Actuator"""
+        _DriveTrainSwig.DriveTrain_Actuator_swiginit(self, _DriveTrainSwig.new_DriveTrain_Actuator())
 
     def connector_1d(self):
-        r"""connector_1d(Actuator self) -> std::shared_ptr< openplx::Physics1D::Charges::MateConnector >"""
-        return _DriveTrainSwig.Actuator_connector_1d(self)
+        r"""connector_1d(DriveTrain_Actuator self) -> std::shared_ptr< openplx::Physics1D::Charges::MateConnector >"""
+        return _DriveTrainSwig.DriveTrain_Actuator_connector_1d(self)
 
     def mate_3d(self):
-        r"""mate_3d(Actuator self) -> std::shared_ptr< openplx::Physics3D::Interactions::Mate >"""
-        return _DriveTrainSwig.Actuator_mate_3d(self)
+        r"""mate_3d(DriveTrain_Actuator self) -> std::shared_ptr< openplx::Physics3D::Interactions::Mate >"""
+        return _DriveTrainSwig.DriveTrain_Actuator_mate_3d(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Actuator self, std::string const & key, Any value)
+        setDynamic(DriveTrain_Actuator self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -6978,22 +6978,22 @@ class Actuator(openplx.Core.Object):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.Actuator_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_Actuator_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Actuator self, std::string const & key) -> Any
+        getDynamic(DriveTrain_Actuator self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.Actuator_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_Actuator_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Actuator self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_Actuator self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -7001,86 +7001,86 @@ class Actuator(openplx.Core.Object):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.Actuator_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_Actuator_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Actuator self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_Actuator self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.Actuator_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_Actuator_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Actuator self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_Actuator self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.Actuator_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_Actuator_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Actuator self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_Actuator self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.Actuator_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_Actuator
+        return _DriveTrainSwig.DriveTrain_Actuator_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_Actuator
 
-# Register Actuator in _DriveTrainSwig:
-_DriveTrainSwig.Actuator_swigregister(Actuator)
+# Register DriveTrain_Actuator in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_Actuator_swigregister(DriveTrain_Actuator)
 
-class ManualClutch(openplx.Physics1D.Interactions_Mate):
+class DriveTrain_ManualClutch(openplx.Physics1D.Physics1D_Interactions_Mate):
     r"""Proxy of C++ openplx::DriveTrain::ManualClutch class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(ManualClutch self) -> ManualClutch"""
-        _DriveTrainSwig.ManualClutch_swiginit(self, _DriveTrainSwig.new_ManualClutch())
+        r"""__init__(DriveTrain_ManualClutch self) -> DriveTrain_ManualClutch"""
+        _DriveTrainSwig.DriveTrain_ManualClutch_swiginit(self, _DriveTrainSwig.new_DriveTrain_ManualClutch())
 
     def initial_engagement_fraction(self):
-        r"""initial_engagement_fraction(ManualClutch self) -> double"""
-        return _DriveTrainSwig.ManualClutch_initial_engagement_fraction(self)
+        r"""initial_engagement_fraction(DriveTrain_ManualClutch self) -> double"""
+        return _DriveTrainSwig.DriveTrain_ManualClutch_initial_engagement_fraction(self)
 
     def torque_capacity(self):
-        r"""torque_capacity(ManualClutch self) -> double"""
-        return _DriveTrainSwig.ManualClutch_torque_capacity(self)
+        r"""torque_capacity(DriveTrain_ManualClutch self) -> double"""
+        return _DriveTrainSwig.DriveTrain_ManualClutch_torque_capacity(self)
 
     def min_relative_slip_ratio(self):
-        r"""min_relative_slip_ratio(ManualClutch self) -> double"""
-        return _DriveTrainSwig.ManualClutch_min_relative_slip_ratio(self)
+        r"""min_relative_slip_ratio(DriveTrain_ManualClutch self) -> double"""
+        return _DriveTrainSwig.DriveTrain_ManualClutch_min_relative_slip_ratio(self)
 
     def slip_velocity_output(self):
-        r"""slip_velocity_output(ManualClutch self) -> std::shared_ptr< openplx::Physics::Signals::RelativeVelocity1DOutput >"""
-        return _DriveTrainSwig.ManualClutch_slip_velocity_output(self)
+        r"""slip_velocity_output(DriveTrain_ManualClutch self) -> std::shared_ptr< openplx::Physics::Signals::RelativeVelocity1DOutput >"""
+        return _DriveTrainSwig.DriveTrain_ManualClutch_slip_velocity_output(self)
 
     def torque_output(self):
-        r"""torque_output(ManualClutch self) -> std::shared_ptr< openplx::Physics::Signals::Torque1DOutput >"""
-        return _DriveTrainSwig.ManualClutch_torque_output(self)
+        r"""torque_output(DriveTrain_ManualClutch self) -> std::shared_ptr< openplx::Physics::Signals::Torque1DOutput >"""
+        return _DriveTrainSwig.DriveTrain_ManualClutch_torque_output(self)
 
     def engagement_fraction_input(self):
-        r"""engagement_fraction_input(ManualClutch self) -> std::shared_ptr< openplx::Physics::Signals::FractionInput >"""
-        return _DriveTrainSwig.ManualClutch_engagement_fraction_input(self)
+        r"""engagement_fraction_input(DriveTrain_ManualClutch self) -> std::shared_ptr< openplx::Physics::Signals::FractionInput >"""
+        return _DriveTrainSwig.DriveTrain_ManualClutch_engagement_fraction_input(self)
 
     def engagement_fraction_output(self):
-        r"""engagement_fraction_output(ManualClutch self) -> std::shared_ptr< openplx::Physics::Signals::FractionOutput >"""
-        return _DriveTrainSwig.ManualClutch_engagement_fraction_output(self)
+        r"""engagement_fraction_output(DriveTrain_ManualClutch self) -> std::shared_ptr< openplx::Physics::Signals::FractionOutput >"""
+        return _DriveTrainSwig.DriveTrain_ManualClutch_engagement_fraction_output(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(ManualClutch self, std::string const & key, Any value)
+        setDynamic(DriveTrain_ManualClutch self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -7088,22 +7088,22 @@ class ManualClutch(openplx.Physics1D.Interactions_Mate):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.ManualClutch_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_ManualClutch_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(ManualClutch self, std::string const & key) -> Any
+        getDynamic(DriveTrain_ManualClutch self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.ManualClutch_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_ManualClutch_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(ManualClutch self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_ManualClutch self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -7111,74 +7111,74 @@ class ManualClutch(openplx.Physics1D.Interactions_Mate):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.ManualClutch_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_ManualClutch_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(ManualClutch self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_ManualClutch self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.ManualClutch_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_ManualClutch_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(ManualClutch self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_ManualClutch self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.ManualClutch_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_ManualClutch_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(ManualClutch self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_ManualClutch self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.ManualClutch_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_ManualClutch
+        return _DriveTrainSwig.DriveTrain_ManualClutch_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_ManualClutch
 
-# Register ManualClutch in _DriveTrainSwig:
-_DriveTrainSwig.ManualClutch_swigregister(ManualClutch)
+# Register DriveTrain_ManualClutch in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_ManualClutch_swigregister(DriveTrain_ManualClutch)
 
-class AutomaticClutch(ManualClutch):
+class DriveTrain_AutomaticClutch(DriveTrain_ManualClutch):
     r"""Proxy of C++ openplx::DriveTrain::AutomaticClutch class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(AutomaticClutch self) -> AutomaticClutch"""
-        _DriveTrainSwig.AutomaticClutch_swiginit(self, _DriveTrainSwig.new_AutomaticClutch())
+        r"""__init__(DriveTrain_AutomaticClutch self) -> DriveTrain_AutomaticClutch"""
+        _DriveTrainSwig.DriveTrain_AutomaticClutch_swiginit(self, _DriveTrainSwig.new_DriveTrain_AutomaticClutch())
 
     def engagement_time(self):
-        r"""engagement_time(AutomaticClutch self) -> double"""
-        return _DriveTrainSwig.AutomaticClutch_engagement_time(self)
+        r"""engagement_time(DriveTrain_AutomaticClutch self) -> double"""
+        return _DriveTrainSwig.DriveTrain_AutomaticClutch_engagement_time(self)
 
     def initially_engaged(self):
-        r"""initially_engaged(AutomaticClutch self) -> bool"""
-        return _DriveTrainSwig.AutomaticClutch_initially_engaged(self)
+        r"""initially_engaged(DriveTrain_AutomaticClutch self) -> bool"""
+        return _DriveTrainSwig.DriveTrain_AutomaticClutch_initially_engaged(self)
 
     def engage_input(self):
-        r"""engage_input(AutomaticClutch self) -> std::shared_ptr< openplx::Physics::Signals::EngageInput >"""
-        return _DriveTrainSwig.AutomaticClutch_engage_input(self)
+        r"""engage_input(DriveTrain_AutomaticClutch self) -> std::shared_ptr< openplx::Physics::Signals::EngageInput >"""
+        return _DriveTrainSwig.DriveTrain_AutomaticClutch_engage_input(self)
 
     def engaged_output(self):
-        r"""engaged_output(AutomaticClutch self) -> std::shared_ptr< openplx::Physics::Signals::EngagedOutput >"""
-        return _DriveTrainSwig.AutomaticClutch_engaged_output(self)
+        r"""engaged_output(DriveTrain_AutomaticClutch self) -> std::shared_ptr< openplx::Physics::Signals::EngagedOutput >"""
+        return _DriveTrainSwig.DriveTrain_AutomaticClutch_engaged_output(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(AutomaticClutch self, std::string const & key, Any value)
+        setDynamic(DriveTrain_AutomaticClutch self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -7186,22 +7186,22 @@ class AutomaticClutch(ManualClutch):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.AutomaticClutch_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_AutomaticClutch_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(AutomaticClutch self, std::string const & key) -> Any
+        getDynamic(DriveTrain_AutomaticClutch self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.AutomaticClutch_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_AutomaticClutch_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(AutomaticClutch self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_AutomaticClutch self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -7209,94 +7209,94 @@ class AutomaticClutch(ManualClutch):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.AutomaticClutch_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_AutomaticClutch_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(AutomaticClutch self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_AutomaticClutch self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.AutomaticClutch_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_AutomaticClutch_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(AutomaticClutch self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_AutomaticClutch self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.AutomaticClutch_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_AutomaticClutch_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(AutomaticClutch self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_AutomaticClutch self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.AutomaticClutch_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_AutomaticClutch
+        return _DriveTrainSwig.DriveTrain_AutomaticClutch_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_AutomaticClutch
 
-# Register AutomaticClutch in _DriveTrainSwig:
-_DriveTrainSwig.AutomaticClutch_swigregister(AutomaticClutch)
+# Register DriveTrain_AutomaticClutch in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_AutomaticClutch_swigregister(DriveTrain_AutomaticClutch)
 
-class CombustionEngine(openplx.Physics.Interactions_Interaction1DOF):
+class DriveTrain_CombustionEngine(openplx.Physics.Physics_Interactions_Interaction1DOF):
     r"""Proxy of C++ openplx::DriveTrain::CombustionEngine class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(CombustionEngine self) -> CombustionEngine"""
-        _DriveTrainSwig.CombustionEngine_swiginit(self, _DriveTrainSwig.new_CombustionEngine())
+        r"""__init__(DriveTrain_CombustionEngine self) -> DriveTrain_CombustionEngine"""
+        _DriveTrainSwig.DriveTrain_CombustionEngine_swiginit(self, _DriveTrainSwig.new_DriveTrain_CombustionEngine())
 
     def displacement_volume(self):
-        r"""displacement_volume(CombustionEngine self) -> double"""
-        return _DriveTrainSwig.CombustionEngine_displacement_volume(self)
+        r"""displacement_volume(DriveTrain_CombustionEngine self) -> double"""
+        return _DriveTrainSwig.DriveTrain_CombustionEngine_displacement_volume(self)
 
     def max_torque(self):
-        r"""max_torque(CombustionEngine self) -> double"""
-        return _DriveTrainSwig.CombustionEngine_max_torque(self)
+        r"""max_torque(DriveTrain_CombustionEngine self) -> double"""
+        return _DriveTrainSwig.DriveTrain_CombustionEngine_max_torque(self)
 
     def max_torque_RPM(self):
-        r"""max_torque_RPM(CombustionEngine self) -> double"""
-        return _DriveTrainSwig.CombustionEngine_max_torque_RPM(self)
+        r"""max_torque_RPM(DriveTrain_CombustionEngine self) -> double"""
+        return _DriveTrainSwig.DriveTrain_CombustionEngine_max_torque_RPM(self)
 
     def max_power_RPM(self):
-        r"""max_power_RPM(CombustionEngine self) -> double"""
-        return _DriveTrainSwig.CombustionEngine_max_power_RPM(self)
+        r"""max_power_RPM(DriveTrain_CombustionEngine self) -> double"""
+        return _DriveTrainSwig.DriveTrain_CombustionEngine_max_power_RPM(self)
 
     def idle_RPM(self):
-        r"""idle_RPM(CombustionEngine self) -> double"""
-        return _DriveTrainSwig.CombustionEngine_idle_RPM(self)
+        r"""idle_RPM(DriveTrain_CombustionEngine self) -> double"""
+        return _DriveTrainSwig.DriveTrain_CombustionEngine_idle_RPM(self)
 
     def crank_shaft_inertia(self):
-        r"""crank_shaft_inertia(CombustionEngine self) -> double"""
-        return _DriveTrainSwig.CombustionEngine_crank_shaft_inertia(self)
+        r"""crank_shaft_inertia(DriveTrain_CombustionEngine self) -> double"""
+        return _DriveTrainSwig.DriveTrain_CombustionEngine_crank_shaft_inertia(self)
 
     def initial_throttle(self):
-        r"""initial_throttle(CombustionEngine self) -> double"""
-        return _DriveTrainSwig.CombustionEngine_initial_throttle(self)
+        r"""initial_throttle(DriveTrain_CombustionEngine self) -> double"""
+        return _DriveTrainSwig.DriveTrain_CombustionEngine_initial_throttle(self)
 
     def torque_output(self):
-        r"""torque_output(CombustionEngine self) -> std::shared_ptr< openplx::Physics::Signals::Torque1DOutput >"""
-        return _DriveTrainSwig.CombustionEngine_torque_output(self)
+        r"""torque_output(DriveTrain_CombustionEngine self) -> std::shared_ptr< openplx::Physics::Signals::Torque1DOutput >"""
+        return _DriveTrainSwig.DriveTrain_CombustionEngine_torque_output(self)
 
     def throttle_input(self):
-        r"""throttle_input(CombustionEngine self) -> std::shared_ptr< openplx::Physics::Signals::FractionInput >"""
-        return _DriveTrainSwig.CombustionEngine_throttle_input(self)
+        r"""throttle_input(DriveTrain_CombustionEngine self) -> std::shared_ptr< openplx::Physics::Signals::FractionInput >"""
+        return _DriveTrainSwig.DriveTrain_CombustionEngine_throttle_input(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(CombustionEngine self, std::string const & key, Any value)
+        setDynamic(DriveTrain_CombustionEngine self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -7304,22 +7304,22 @@ class CombustionEngine(openplx.Physics.Interactions_Interaction1DOF):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.CombustionEngine_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_CombustionEngine_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(CombustionEngine self, std::string const & key) -> Any
+        getDynamic(DriveTrain_CombustionEngine self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.CombustionEngine_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_CombustionEngine_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(CombustionEngine self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_CombustionEngine self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -7327,74 +7327,74 @@ class CombustionEngine(openplx.Physics.Interactions_Interaction1DOF):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.CombustionEngine_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_CombustionEngine_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(CombustionEngine self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_CombustionEngine self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.CombustionEngine_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_CombustionEngine_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(CombustionEngine self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_CombustionEngine self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.CombustionEngine_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_CombustionEngine_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(CombustionEngine self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_CombustionEngine self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.CombustionEngine_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_CombustionEngine
+        return _DriveTrainSwig.DriveTrain_CombustionEngine_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_CombustionEngine
 
-# Register CombustionEngine in _DriveTrainSwig:
-_DriveTrainSwig.CombustionEngine_swigregister(CombustionEngine)
+# Register DriveTrain_CombustionEngine in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_CombustionEngine_swigregister(DriveTrain_CombustionEngine)
 
-class Differential(openplx.Physics1D.Interactions_Mate):
+class DriveTrain_Differential(openplx.Physics1D.Physics1D_Interactions_Mate):
     r"""Proxy of C++ openplx::DriveTrain::Differential class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Differential self) -> Differential"""
-        _DriveTrainSwig.Differential_swiginit(self, _DriveTrainSwig.new_Differential())
+        r"""__init__(DriveTrain_Differential self) -> DriveTrain_Differential"""
+        _DriveTrainSwig.DriveTrain_Differential_swiginit(self, _DriveTrainSwig.new_DriveTrain_Differential())
 
     def drive_shaft(self):
-        r"""drive_shaft(Differential self) -> std::shared_ptr< openplx::DriveTrain::Shaft >"""
-        return _DriveTrainSwig.Differential_drive_shaft(self)
+        r"""drive_shaft(DriveTrain_Differential self) -> std::shared_ptr< openplx::DriveTrain::Shaft >"""
+        return _DriveTrainSwig.DriveTrain_Differential_drive_shaft(self)
 
     def left_axle_shaft(self):
-        r"""left_axle_shaft(Differential self) -> std::shared_ptr< openplx::DriveTrain::Shaft >"""
-        return _DriveTrainSwig.Differential_left_axle_shaft(self)
+        r"""left_axle_shaft(DriveTrain_Differential self) -> std::shared_ptr< openplx::DriveTrain::Shaft >"""
+        return _DriveTrainSwig.DriveTrain_Differential_left_axle_shaft(self)
 
     def right_axle_shaft(self):
-        r"""right_axle_shaft(Differential self) -> std::shared_ptr< openplx::DriveTrain::Shaft >"""
-        return _DriveTrainSwig.Differential_right_axle_shaft(self)
+        r"""right_axle_shaft(DriveTrain_Differential self) -> std::shared_ptr< openplx::DriveTrain::Shaft >"""
+        return _DriveTrainSwig.DriveTrain_Differential_right_axle_shaft(self)
 
     def gear_ratio(self):
-        r"""gear_ratio(Differential self) -> double"""
-        return _DriveTrainSwig.Differential_gear_ratio(self)
+        r"""gear_ratio(DriveTrain_Differential self) -> double"""
+        return _DriveTrainSwig.DriveTrain_Differential_gear_ratio(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Differential self, std::string const & key, Any value)
+        setDynamic(DriveTrain_Differential self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -7402,22 +7402,22 @@ class Differential(openplx.Physics1D.Interactions_Mate):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.Differential_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_Differential_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Differential self, std::string const & key) -> Any
+        getDynamic(DriveTrain_Differential self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.Differential_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_Differential_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Differential self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_Differential self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -7425,138 +7425,138 @@ class Differential(openplx.Physics1D.Interactions_Mate):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.Differential_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_Differential_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Differential self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_Differential self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.Differential_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_Differential_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Differential self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_Differential self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.Differential_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_Differential_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Differential self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_Differential self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.Differential_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_Differential
+        return _DriveTrainSwig.DriveTrain_Differential_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_Differential
 
-# Register Differential in _DriveTrainSwig:
-_DriveTrainSwig.Differential_swigregister(Differential)
+# Register DriveTrain_Differential in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_Differential_swigregister(DriveTrain_Differential)
 
-class EmpiricalTorqueConverter(openplx.Physics1D.Interactions_Mate):
+class DriveTrain_EmpiricalTorqueConverter(openplx.Physics1D.Physics1D_Interactions_Mate):
     r"""Proxy of C++ openplx::DriveTrain::EmpiricalTorqueConverter class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(EmpiricalTorqueConverter self) -> EmpiricalTorqueConverter"""
-        _DriveTrainSwig.EmpiricalTorqueConverter_swiginit(self, _DriveTrainSwig.new_EmpiricalTorqueConverter())
+        r"""__init__(DriveTrain_EmpiricalTorqueConverter self) -> DriveTrain_EmpiricalTorqueConverter"""
+        _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_swiginit(self, _DriveTrainSwig.new_DriveTrain_EmpiricalTorqueConverter())
 
     def oil_density(self):
-        r"""oil_density(EmpiricalTorqueConverter self) -> double"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_oil_density(self)
+        r"""oil_density(DriveTrain_EmpiricalTorqueConverter self) -> double"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_oil_density(self)
 
     def diameter(self):
-        r"""diameter(EmpiricalTorqueConverter self) -> double"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_diameter(self)
+        r"""diameter(DriveTrain_EmpiricalTorqueConverter self) -> double"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_diameter(self)
 
     def lock_up_time(self):
-        r"""lock_up_time(EmpiricalTorqueConverter self) -> double"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_lock_up_time(self)
+        r"""lock_up_time(DriveTrain_EmpiricalTorqueConverter self) -> double"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_lock_up_time(self)
 
     def lock_up_input(self):
-        r"""lock_up_input(EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput >"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_lock_up_input(self)
+        r"""lock_up_input(DriveTrain_EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockUpInput >"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_lock_up_input(self)
 
     def locked_up_output(self):
-        r"""locked_up_output(EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput >"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_locked_up_output(self)
+        r"""locked_up_output(DriveTrain_EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput >"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_locked_up_output(self)
 
     def velocity_ratio_torque_multiplier_list(self):
-        r"""velocity_ratio_torque_multiplier_list(EmpiricalTorqueConverter self) -> DriveTrain_VelocityRatioTorqueMultiplicationPair_Vector"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_velocity_ratio_torque_multiplier_list(self)
+        r"""velocity_ratio_torque_multiplier_list(DriveTrain_EmpiricalTorqueConverter self) -> DriveTrain_VelocityRatioTorqueMultiplicationPair_Vector"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_velocity_ratio_torque_multiplier_list(self)
 
     def velocity_ratio_geometry_factor_list(self):
-        r"""velocity_ratio_geometry_factor_list(EmpiricalTorqueConverter self) -> DriveTrain_VelocityRatioGeometryFactorPair_Vector"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_velocity_ratio_geometry_factor_list(self)
+        r"""velocity_ratio_geometry_factor_list(DriveTrain_EmpiricalTorqueConverter self) -> DriveTrain_VelocityRatioGeometryFactorPair_Vector"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_velocity_ratio_geometry_factor_list(self)
 
     def factor_pair1(self):
-        r"""factor_pair1(EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioGeometryFactorPair >"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_factor_pair1(self)
+        r"""factor_pair1(DriveTrain_EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioGeometryFactorPair >"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_factor_pair1(self)
 
     def factor_pair2(self):
-        r"""factor_pair2(EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioGeometryFactorPair >"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_factor_pair2(self)
+        r"""factor_pair2(DriveTrain_EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioGeometryFactorPair >"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_factor_pair2(self)
 
     def factor_pair3(self):
-        r"""factor_pair3(EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioGeometryFactorPair >"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_factor_pair3(self)
+        r"""factor_pair3(DriveTrain_EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioGeometryFactorPair >"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_factor_pair3(self)
 
     def factor_pair4(self):
-        r"""factor_pair4(EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioGeometryFactorPair >"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_factor_pair4(self)
+        r"""factor_pair4(DriveTrain_EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioGeometryFactorPair >"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_factor_pair4(self)
 
     def factor_pair5(self):
-        r"""factor_pair5(EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioGeometryFactorPair >"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_factor_pair5(self)
+        r"""factor_pair5(DriveTrain_EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioGeometryFactorPair >"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_factor_pair5(self)
 
     def mult_pair1(self):
-        r"""mult_pair1(EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioTorqueMultiplicationPair >"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_mult_pair1(self)
+        r"""mult_pair1(DriveTrain_EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioTorqueMultiplicationPair >"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_mult_pair1(self)
 
     def mult_pair2(self):
-        r"""mult_pair2(EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioTorqueMultiplicationPair >"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_mult_pair2(self)
+        r"""mult_pair2(DriveTrain_EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioTorqueMultiplicationPair >"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_mult_pair2(self)
 
     def mult_pair3(self):
-        r"""mult_pair3(EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioTorqueMultiplicationPair >"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_mult_pair3(self)
+        r"""mult_pair3(DriveTrain_EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioTorqueMultiplicationPair >"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_mult_pair3(self)
 
     def mult_pair4(self):
-        r"""mult_pair4(EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioTorqueMultiplicationPair >"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_mult_pair4(self)
+        r"""mult_pair4(DriveTrain_EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioTorqueMultiplicationPair >"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_mult_pair4(self)
 
     def mult_pair5(self):
-        r"""mult_pair5(EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioTorqueMultiplicationPair >"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_mult_pair5(self)
+        r"""mult_pair5(DriveTrain_EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioTorqueMultiplicationPair >"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_mult_pair5(self)
 
     def mult_pair6(self):
-        r"""mult_pair6(EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioTorqueMultiplicationPair >"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_mult_pair6(self)
+        r"""mult_pair6(DriveTrain_EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioTorqueMultiplicationPair >"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_mult_pair6(self)
 
     def mult_pair7(self):
-        r"""mult_pair7(EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioTorqueMultiplicationPair >"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_mult_pair7(self)
+        r"""mult_pair7(DriveTrain_EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::DriveTrain::VelocityRatioTorqueMultiplicationPair >"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_mult_pair7(self)
 
     def slip_velocity_output(self):
-        r"""slip_velocity_output(EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::Physics::Signals::RelativeVelocity1DOutput >"""
-        return _DriveTrainSwig.EmpiricalTorqueConverter_slip_velocity_output(self)
+        r"""slip_velocity_output(DriveTrain_EmpiricalTorqueConverter self) -> std::shared_ptr< openplx::Physics::Signals::RelativeVelocity1DOutput >"""
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_slip_velocity_output(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(EmpiricalTorqueConverter self, std::string const & key, Any value)
+        setDynamic(DriveTrain_EmpiricalTorqueConverter self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -7564,22 +7564,22 @@ class EmpiricalTorqueConverter(openplx.Physics1D.Interactions_Mate):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.EmpiricalTorqueConverter_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(EmpiricalTorqueConverter self, std::string const & key) -> Any
+        getDynamic(DriveTrain_EmpiricalTorqueConverter self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.EmpiricalTorqueConverter_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(EmpiricalTorqueConverter self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_EmpiricalTorqueConverter self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -7587,74 +7587,74 @@ class EmpiricalTorqueConverter(openplx.Physics1D.Interactions_Mate):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.EmpiricalTorqueConverter_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(EmpiricalTorqueConverter self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_EmpiricalTorqueConverter self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.EmpiricalTorqueConverter_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(EmpiricalTorqueConverter self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_EmpiricalTorqueConverter self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.EmpiricalTorqueConverter_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(EmpiricalTorqueConverter self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_EmpiricalTorqueConverter self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.EmpiricalTorqueConverter_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_EmpiricalTorqueConverter
+        return _DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_EmpiricalTorqueConverter
 
-# Register EmpiricalTorqueConverter in _DriveTrainSwig:
-_DriveTrainSwig.EmpiricalTorqueConverter_swigregister(EmpiricalTorqueConverter)
+# Register DriveTrain_EmpiricalTorqueConverter in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_EmpiricalTorqueConverter_swigregister(DriveTrain_EmpiricalTorqueConverter)
 
-class Gear(openplx.Physics1D.Interactions_Mate):
+class DriveTrain_Gear(openplx.Physics1D.Physics1D_Interactions_Mate):
     r"""Proxy of C++ openplx::DriveTrain::Gear class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Gear self) -> Gear"""
-        _DriveTrainSwig.Gear_swiginit(self, _DriveTrainSwig.new_Gear())
+        r"""__init__(DriveTrain_Gear self) -> DriveTrain_Gear"""
+        _DriveTrainSwig.DriveTrain_Gear_swiginit(self, _DriveTrainSwig.new_DriveTrain_Gear())
 
     def ratio(self):
-        r"""ratio(Gear self) -> double"""
-        return _DriveTrainSwig.Gear_ratio(self)
+        r"""ratio(DriveTrain_Gear self) -> double"""
+        return _DriveTrainSwig.DriveTrain_Gear_ratio(self)
 
     def torque_output(self):
-        r"""torque_output(Gear self) -> std::shared_ptr< openplx::Physics::Signals::Torque1DOutput >"""
-        return _DriveTrainSwig.Gear_torque_output(self)
+        r"""torque_output(DriveTrain_Gear self) -> std::shared_ptr< openplx::Physics::Signals::Torque1DOutput >"""
+        return _DriveTrainSwig.DriveTrain_Gear_torque_output(self)
 
     def ratio_input(self):
-        r"""ratio_input(Gear self) -> std::shared_ptr< openplx::Physics::Signals::FractionInput >"""
-        return _DriveTrainSwig.Gear_ratio_input(self)
+        r"""ratio_input(DriveTrain_Gear self) -> std::shared_ptr< openplx::Physics::Signals::FractionInput >"""
+        return _DriveTrainSwig.DriveTrain_Gear_ratio_input(self)
 
     def ratio_output(self):
-        r"""ratio_output(Gear self) -> std::shared_ptr< openplx::Physics::Signals::FractionOutput >"""
-        return _DriveTrainSwig.Gear_ratio_output(self)
+        r"""ratio_output(DriveTrain_Gear self) -> std::shared_ptr< openplx::Physics::Signals::FractionOutput >"""
+        return _DriveTrainSwig.DriveTrain_Gear_ratio_output(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Gear self, std::string const & key, Any value)
+        setDynamic(DriveTrain_Gear self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -7662,22 +7662,22 @@ class Gear(openplx.Physics1D.Interactions_Mate):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.Gear_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_Gear_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Gear self, std::string const & key) -> Any
+        getDynamic(DriveTrain_Gear self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.Gear_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_Gear_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Gear self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_Gear self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -7685,66 +7685,66 @@ class Gear(openplx.Physics1D.Interactions_Mate):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.Gear_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_Gear_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Gear self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_Gear self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.Gear_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_Gear_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Gear self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_Gear self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.Gear_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_Gear_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Gear self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_Gear self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.Gear_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_Gear
+        return _DriveTrainSwig.DriveTrain_Gear_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_Gear
 
-# Register Gear in _DriveTrainSwig:
-_DriveTrainSwig.Gear_swigregister(Gear)
+# Register DriveTrain_Gear in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_Gear_swigregister(DriveTrain_Gear)
 
-class FlexibleGear(Gear):
+class DriveTrain_FlexibleGear(DriveTrain_Gear):
     r"""Proxy of C++ openplx::DriveTrain::FlexibleGear class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(FlexibleGear self) -> FlexibleGear"""
-        _DriveTrainSwig.FlexibleGear_swiginit(self, _DriveTrainSwig.new_FlexibleGear())
+        r"""__init__(DriveTrain_FlexibleGear self) -> DriveTrain_FlexibleGear"""
+        _DriveTrainSwig.DriveTrain_FlexibleGear_swiginit(self, _DriveTrainSwig.new_DriveTrain_FlexibleGear())
 
     def flexibility(self):
-        r"""flexibility(FlexibleGear self) -> std::shared_ptr< openplx::Physics::Interactions::Flexibility::DefaultFlexibility >"""
-        return _DriveTrainSwig.FlexibleGear_flexibility(self)
+        r"""flexibility(DriveTrain_FlexibleGear self) -> std::shared_ptr< openplx::Physics::Interactions::Flexibility::DefaultFlexibility >"""
+        return _DriveTrainSwig.DriveTrain_FlexibleGear_flexibility(self)
 
     def dissipation(self):
-        r"""dissipation(FlexibleGear self) -> std::shared_ptr< openplx::Physics::Interactions::Dissipation::DefaultDissipation >"""
-        return _DriveTrainSwig.FlexibleGear_dissipation(self)
+        r"""dissipation(DriveTrain_FlexibleGear self) -> std::shared_ptr< openplx::Physics::Interactions::Dissipation::DefaultDissipation >"""
+        return _DriveTrainSwig.DriveTrain_FlexibleGear_dissipation(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(FlexibleGear self, std::string const & key, Any value)
+        setDynamic(DriveTrain_FlexibleGear self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -7752,22 +7752,22 @@ class FlexibleGear(Gear):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.FlexibleGear_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_FlexibleGear_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(FlexibleGear self, std::string const & key) -> Any
+        getDynamic(DriveTrain_FlexibleGear self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.FlexibleGear_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_FlexibleGear_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(FlexibleGear self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_FlexibleGear self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -7775,90 +7775,90 @@ class FlexibleGear(Gear):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.FlexibleGear_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_FlexibleGear_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(FlexibleGear self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_FlexibleGear self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.FlexibleGear_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_FlexibleGear_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(FlexibleGear self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_FlexibleGear self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.FlexibleGear_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_FlexibleGear_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(FlexibleGear self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_FlexibleGear self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.FlexibleGear_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_FlexibleGear
+        return _DriveTrainSwig.DriveTrain_FlexibleGear_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_FlexibleGear
 
-# Register FlexibleGear in _DriveTrainSwig:
-_DriveTrainSwig.FlexibleGear_swigregister(FlexibleGear)
+# Register DriveTrain_FlexibleGear in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_FlexibleGear_swigregister(DriveTrain_FlexibleGear)
 
-class GearBox(openplx.Physics1D.Interactions_Mate):
+class DriveTrain_GearBox(openplx.Physics1D.Physics1D_Interactions_Mate):
     r"""Proxy of C++ openplx::DriveTrain::GearBox class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(GearBox self) -> GearBox"""
-        _DriveTrainSwig.GearBox_swiginit(self, _DriveTrainSwig.new_GearBox())
+        r"""__init__(DriveTrain_GearBox self) -> DriveTrain_GearBox"""
+        _DriveTrainSwig.DriveTrain_GearBox_swiginit(self, _DriveTrainSwig.new_DriveTrain_GearBox())
 
     def forward_gears(self):
-        r"""forward_gears(GearBox self) -> DoubleVector"""
-        return _DriveTrainSwig.GearBox_forward_gears(self)
+        r"""forward_gears(DriveTrain_GearBox self) -> DoubleVector"""
+        return _DriveTrainSwig.DriveTrain_GearBox_forward_gears(self)
 
     def reverse_gears(self):
-        r"""reverse_gears(GearBox self) -> DoubleVector"""
-        return _DriveTrainSwig.GearBox_reverse_gears(self)
+        r"""reverse_gears(DriveTrain_GearBox self) -> DoubleVector"""
+        return _DriveTrainSwig.DriveTrain_GearBox_reverse_gears(self)
 
     def initial_gear(self):
-        r"""initial_gear(GearBox self) -> int64_t"""
-        return _DriveTrainSwig.GearBox_initial_gear(self)
+        r"""initial_gear(DriveTrain_GearBox self) -> int64_t"""
+        return _DriveTrainSwig.DriveTrain_GearBox_initial_gear(self)
 
     def flexibility(self):
-        r"""flexibility(GearBox self) -> std::shared_ptr< openplx::Physics::Interactions::Flexibility::DefaultFlexibility >"""
-        return _DriveTrainSwig.GearBox_flexibility(self)
+        r"""flexibility(DriveTrain_GearBox self) -> std::shared_ptr< openplx::Physics::Interactions::Flexibility::DefaultFlexibility >"""
+        return _DriveTrainSwig.DriveTrain_GearBox_flexibility(self)
 
     def dissipation(self):
-        r"""dissipation(GearBox self) -> std::shared_ptr< openplx::Physics::Interactions::Dissipation::DefaultDissipation >"""
-        return _DriveTrainSwig.GearBox_dissipation(self)
+        r"""dissipation(DriveTrain_GearBox self) -> std::shared_ptr< openplx::Physics::Interactions::Dissipation::DefaultDissipation >"""
+        return _DriveTrainSwig.DriveTrain_GearBox_dissipation(self)
 
     def torque_output(self):
-        r"""torque_output(GearBox self) -> std::shared_ptr< openplx::Physics::Signals::Torque1DOutput >"""
-        return _DriveTrainSwig.GearBox_torque_output(self)
+        r"""torque_output(DriveTrain_GearBox self) -> std::shared_ptr< openplx::Physics::Signals::Torque1DOutput >"""
+        return _DriveTrainSwig.DriveTrain_GearBox_torque_output(self)
 
     def gear_selection_input(self):
-        r"""gear_selection_input(GearBox self) -> std::shared_ptr< openplx::Physics::Signals::IntInput >"""
-        return _DriveTrainSwig.GearBox_gear_selection_input(self)
+        r"""gear_selection_input(DriveTrain_GearBox self) -> std::shared_ptr< openplx::Physics::Signals::IntInput >"""
+        return _DriveTrainSwig.DriveTrain_GearBox_gear_selection_input(self)
 
     def gear_selection_output(self):
-        r"""gear_selection_output(GearBox self) -> std::shared_ptr< openplx::Physics::Signals::IntOutput >"""
-        return _DriveTrainSwig.GearBox_gear_selection_output(self)
+        r"""gear_selection_output(DriveTrain_GearBox self) -> std::shared_ptr< openplx::Physics::Signals::IntOutput >"""
+        return _DriveTrainSwig.DriveTrain_GearBox_gear_selection_output(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(GearBox self, std::string const & key, Any value)
+        setDynamic(DriveTrain_GearBox self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -7866,22 +7866,22 @@ class GearBox(openplx.Physics1D.Interactions_Mate):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.GearBox_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_GearBox_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(GearBox self, std::string const & key) -> Any
+        getDynamic(DriveTrain_GearBox self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.GearBox_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_GearBox_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(GearBox self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_GearBox self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -7889,62 +7889,62 @@ class GearBox(openplx.Physics1D.Interactions_Mate):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.GearBox_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_GearBox_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(GearBox self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_GearBox self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.GearBox_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_GearBox_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(GearBox self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_GearBox self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.GearBox_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_GearBox_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(GearBox self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_GearBox self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.GearBox_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_GearBox
+        return _DriveTrainSwig.DriveTrain_GearBox_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_GearBox
 
-# Register GearBox in _DriveTrainSwig:
-_DriveTrainSwig.GearBox_swigregister(GearBox)
+# Register DriveTrain_GearBox in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_GearBox_swigregister(DriveTrain_GearBox)
 
-class HingeActuator(Actuator):
+class DriveTrain_HingeActuator(DriveTrain_Actuator):
     r"""Proxy of C++ openplx::DriveTrain::HingeActuator class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(HingeActuator self) -> HingeActuator"""
-        _DriveTrainSwig.HingeActuator_swiginit(self, _DriveTrainSwig.new_HingeActuator())
+        r"""__init__(DriveTrain_HingeActuator self) -> DriveTrain_HingeActuator"""
+        _DriveTrainSwig.DriveTrain_HingeActuator_swiginit(self, _DriveTrainSwig.new_DriveTrain_HingeActuator())
 
     def mate_3d(self):
-        r"""mate_3d(HingeActuator self) -> std::shared_ptr< openplx::Physics3D::Interactions::Hinge >"""
-        return _DriveTrainSwig.HingeActuator_mate_3d(self)
+        r"""mate_3d(DriveTrain_HingeActuator self) -> std::shared_ptr< openplx::Physics3D::Interactions::Hinge >"""
+        return _DriveTrainSwig.DriveTrain_HingeActuator_mate_3d(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(HingeActuator self, std::string const & key, Any value)
+        setDynamic(DriveTrain_HingeActuator self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -7952,22 +7952,22 @@ class HingeActuator(Actuator):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.HingeActuator_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_HingeActuator_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(HingeActuator self, std::string const & key) -> Any
+        getDynamic(DriveTrain_HingeActuator self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.HingeActuator_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_HingeActuator_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(HingeActuator self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_HingeActuator self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -7975,62 +7975,62 @@ class HingeActuator(Actuator):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.HingeActuator_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_HingeActuator_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(HingeActuator self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_HingeActuator self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.HingeActuator_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_HingeActuator_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(HingeActuator self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_HingeActuator self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.HingeActuator_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_HingeActuator_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(HingeActuator self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_HingeActuator self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.HingeActuator_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_HingeActuator
+        return _DriveTrainSwig.DriveTrain_HingeActuator_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_HingeActuator
 
-# Register HingeActuator in _DriveTrainSwig:
-_DriveTrainSwig.HingeActuator_swigregister(HingeActuator)
+# Register DriveTrain_HingeActuator in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_HingeActuator_swigregister(DriveTrain_HingeActuator)
 
-class PrismaticActuator(Actuator):
+class DriveTrain_PrismaticActuator(DriveTrain_Actuator):
     r"""Proxy of C++ openplx::DriveTrain::PrismaticActuator class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(PrismaticActuator self) -> PrismaticActuator"""
-        _DriveTrainSwig.PrismaticActuator_swiginit(self, _DriveTrainSwig.new_PrismaticActuator())
+        r"""__init__(DriveTrain_PrismaticActuator self) -> DriveTrain_PrismaticActuator"""
+        _DriveTrainSwig.DriveTrain_PrismaticActuator_swiginit(self, _DriveTrainSwig.new_DriveTrain_PrismaticActuator())
 
     def mate_3d(self):
-        r"""mate_3d(PrismaticActuator self) -> std::shared_ptr< openplx::Physics3D::Interactions::Prismatic >"""
-        return _DriveTrainSwig.PrismaticActuator_mate_3d(self)
+        r"""mate_3d(DriveTrain_PrismaticActuator self) -> std::shared_ptr< openplx::Physics3D::Interactions::Prismatic >"""
+        return _DriveTrainSwig.DriveTrain_PrismaticActuator_mate_3d(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(PrismaticActuator self, std::string const & key, Any value)
+        setDynamic(DriveTrain_PrismaticActuator self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -8038,22 +8038,22 @@ class PrismaticActuator(Actuator):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.PrismaticActuator_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_PrismaticActuator_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(PrismaticActuator self, std::string const & key) -> Any
+        getDynamic(DriveTrain_PrismaticActuator self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.PrismaticActuator_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_PrismaticActuator_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(PrismaticActuator self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_PrismaticActuator self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -8061,66 +8061,66 @@ class PrismaticActuator(Actuator):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.PrismaticActuator_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_PrismaticActuator_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(PrismaticActuator self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_PrismaticActuator self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.PrismaticActuator_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_PrismaticActuator_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(PrismaticActuator self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_PrismaticActuator self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.PrismaticActuator_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_PrismaticActuator_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(PrismaticActuator self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_PrismaticActuator self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.PrismaticActuator_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_PrismaticActuator
+        return _DriveTrainSwig.DriveTrain_PrismaticActuator_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_PrismaticActuator
 
-# Register PrismaticActuator in _DriveTrainSwig:
-_DriveTrainSwig.PrismaticActuator_swigregister(PrismaticActuator)
+# Register DriveTrain_PrismaticActuator in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_PrismaticActuator_swigregister(DriveTrain_PrismaticActuator)
 
-class Shaft(openplx.Physics1D.Bodies_RotationalBody):
+class DriveTrain_Shaft(openplx.Physics1D.Physics1D_Bodies_RotationalBody):
     r"""Proxy of C++ openplx::DriveTrain::Shaft class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Shaft self) -> Shaft"""
-        _DriveTrainSwig.Shaft_swiginit(self, _DriveTrainSwig.new_Shaft())
+        r"""__init__(DriveTrain_Shaft self) -> DriveTrain_Shaft"""
+        _DriveTrainSwig.DriveTrain_Shaft_swiginit(self, _DriveTrainSwig.new_DriveTrain_Shaft())
 
     def input(self):
-        r"""input(Shaft self) -> std::shared_ptr< openplx::Physics1D::Charges::MateConnector >"""
-        return _DriveTrainSwig.Shaft_input(self)
+        r"""input(DriveTrain_Shaft self) -> std::shared_ptr< openplx::Physics1D::Charges::MateConnector >"""
+        return _DriveTrainSwig.DriveTrain_Shaft_input(self)
 
     def output(self):
-        r"""output(Shaft self) -> std::shared_ptr< openplx::Physics1D::Charges::MateConnector >"""
-        return _DriveTrainSwig.Shaft_output(self)
+        r"""output(DriveTrain_Shaft self) -> std::shared_ptr< openplx::Physics1D::Charges::MateConnector >"""
+        return _DriveTrainSwig.DriveTrain_Shaft_output(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Shaft self, std::string const & key, Any value)
+        setDynamic(DriveTrain_Shaft self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -8128,22 +8128,22 @@ class Shaft(openplx.Physics1D.Bodies_RotationalBody):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.Shaft_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_Shaft_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Shaft self, std::string const & key) -> Any
+        getDynamic(DriveTrain_Shaft self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.Shaft_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_Shaft_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Shaft self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_Shaft self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -8151,58 +8151,58 @@ class Shaft(openplx.Physics1D.Bodies_RotationalBody):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.Shaft_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_Shaft_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Shaft self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_Shaft self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.Shaft_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_Shaft_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Shaft self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_Shaft self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.Shaft_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_Shaft_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Shaft self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_Shaft self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.Shaft_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_Shaft
+        return _DriveTrainSwig.DriveTrain_Shaft_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_Shaft
 
-# Register Shaft in _DriveTrainSwig:
-_DriveTrainSwig.Shaft_swigregister(Shaft)
+# Register DriveTrain_Shaft in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_Shaft_swigregister(DriveTrain_Shaft)
 
-class Signals_TorqueConverterLockUpInput(openplx.Physics.Signals_BoolInput):
+class DriveTrain_Signals_TorqueConverterLockUpInput(openplx.Physics.Physics_Signals_BoolInput):
     r"""Proxy of C++ openplx::DriveTrain::Signals::TorqueConverterLockUpInput class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Signals_TorqueConverterLockUpInput self) -> Signals_TorqueConverterLockUpInput"""
-        _DriveTrainSwig.Signals_TorqueConverterLockUpInput_swiginit(self, _DriveTrainSwig.new_Signals_TorqueConverterLockUpInput())
+        r"""__init__(DriveTrain_Signals_TorqueConverterLockUpInput self) -> DriveTrain_Signals_TorqueConverterLockUpInput"""
+        _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_swiginit(self, _DriveTrainSwig.new_DriveTrain_Signals_TorqueConverterLockUpInput())
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Signals_TorqueConverterLockUpInput self, std::string const & key, Any value)
+        setDynamic(DriveTrain_Signals_TorqueConverterLockUpInput self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -8210,22 +8210,22 @@ class Signals_TorqueConverterLockUpInput(openplx.Physics.Signals_BoolInput):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterLockUpInput_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Signals_TorqueConverterLockUpInput self, std::string const & key) -> Any
+        getDynamic(DriveTrain_Signals_TorqueConverterLockUpInput self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterLockUpInput_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Signals_TorqueConverterLockUpInput self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_Signals_TorqueConverterLockUpInput self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -8233,58 +8233,58 @@ class Signals_TorqueConverterLockUpInput(openplx.Physics.Signals_BoolInput):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterLockUpInput_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Signals_TorqueConverterLockUpInput self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_Signals_TorqueConverterLockUpInput self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterLockUpInput_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Signals_TorqueConverterLockUpInput self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_Signals_TorqueConverterLockUpInput self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterLockUpInput_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Signals_TorqueConverterLockUpInput self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_Signals_TorqueConverterLockUpInput self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterLockUpInput_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_Signals_TorqueConverterLockUpInput
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_Signals_TorqueConverterLockUpInput
 
-# Register Signals_TorqueConverterLockUpInput in _DriveTrainSwig:
-_DriveTrainSwig.Signals_TorqueConverterLockUpInput_swigregister(Signals_TorqueConverterLockUpInput)
+# Register DriveTrain_Signals_TorqueConverterLockUpInput in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockUpInput_swigregister(DriveTrain_Signals_TorqueConverterLockUpInput)
 
-class Signals_TorqueConverterLockedUpOutput(openplx.Physics.Signals_BoolOutput):
+class DriveTrain_Signals_TorqueConverterLockedUpOutput(openplx.Physics.Physics_Signals_BoolOutput):
     r"""Proxy of C++ openplx::DriveTrain::Signals::TorqueConverterLockedUpOutput class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Signals_TorqueConverterLockedUpOutput self) -> Signals_TorqueConverterLockedUpOutput"""
-        _DriveTrainSwig.Signals_TorqueConverterLockedUpOutput_swiginit(self, _DriveTrainSwig.new_Signals_TorqueConverterLockedUpOutput())
+        r"""__init__(DriveTrain_Signals_TorqueConverterLockedUpOutput self) -> DriveTrain_Signals_TorqueConverterLockedUpOutput"""
+        _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_swiginit(self, _DriveTrainSwig.new_DriveTrain_Signals_TorqueConverterLockedUpOutput())
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Signals_TorqueConverterLockedUpOutput self, std::string const & key, Any value)
+        setDynamic(DriveTrain_Signals_TorqueConverterLockedUpOutput self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -8292,22 +8292,22 @@ class Signals_TorqueConverterLockedUpOutput(openplx.Physics.Signals_BoolOutput):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterLockedUpOutput_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Signals_TorqueConverterLockedUpOutput self, std::string const & key) -> Any
+        getDynamic(DriveTrain_Signals_TorqueConverterLockedUpOutput self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterLockedUpOutput_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Signals_TorqueConverterLockedUpOutput self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_Signals_TorqueConverterLockedUpOutput self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -8315,62 +8315,62 @@ class Signals_TorqueConverterLockedUpOutput(openplx.Physics.Signals_BoolOutput):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterLockedUpOutput_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Signals_TorqueConverterLockedUpOutput self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_Signals_TorqueConverterLockedUpOutput self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterLockedUpOutput_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Signals_TorqueConverterLockedUpOutput self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_Signals_TorqueConverterLockedUpOutput self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterLockedUpOutput_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Signals_TorqueConverterLockedUpOutput self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_Signals_TorqueConverterLockedUpOutput self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterLockedUpOutput_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_Signals_TorqueConverterLockedUpOutput
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_Signals_TorqueConverterLockedUpOutput
 
-# Register Signals_TorqueConverterLockedUpOutput in _DriveTrainSwig:
-_DriveTrainSwig.Signals_TorqueConverterLockedUpOutput_swigregister(Signals_TorqueConverterLockedUpOutput)
+# Register DriveTrain_Signals_TorqueConverterLockedUpOutput in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_Signals_TorqueConverterLockedUpOutput_swigregister(DriveTrain_Signals_TorqueConverterLockedUpOutput)
 
-class Signals_TorqueConverterPumpTorqueOutput(openplx.Physics.Signals_Output):
+class DriveTrain_Signals_TorqueConverterPumpTorqueOutput(openplx.Physics.Physics_Signals_Output):
     r"""Proxy of C++ openplx::DriveTrain::Signals::TorqueConverterPumpTorqueOutput class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Signals_TorqueConverterPumpTorqueOutput self) -> Signals_TorqueConverterPumpTorqueOutput"""
-        _DriveTrainSwig.Signals_TorqueConverterPumpTorqueOutput_swiginit(self, _DriveTrainSwig.new_Signals_TorqueConverterPumpTorqueOutput())
+        r"""__init__(DriveTrain_Signals_TorqueConverterPumpTorqueOutput self) -> DriveTrain_Signals_TorqueConverterPumpTorqueOutput"""
+        _DriveTrainSwig.DriveTrain_Signals_TorqueConverterPumpTorqueOutput_swiginit(self, _DriveTrainSwig.new_DriveTrain_Signals_TorqueConverterPumpTorqueOutput())
 
     def torque_converter(self):
-        r"""torque_converter(Signals_TorqueConverterPumpTorqueOutput self) -> std::shared_ptr< openplx::DriveTrain::EmpiricalTorqueConverter >"""
-        return _DriveTrainSwig.Signals_TorqueConverterPumpTorqueOutput_torque_converter(self)
+        r"""torque_converter(DriveTrain_Signals_TorqueConverterPumpTorqueOutput self) -> std::shared_ptr< openplx::DriveTrain::EmpiricalTorqueConverter >"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterPumpTorqueOutput_torque_converter(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Signals_TorqueConverterPumpTorqueOutput self, std::string const & key, Any value)
+        setDynamic(DriveTrain_Signals_TorqueConverterPumpTorqueOutput self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -8378,22 +8378,22 @@ class Signals_TorqueConverterPumpTorqueOutput(openplx.Physics.Signals_Output):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterPumpTorqueOutput_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterPumpTorqueOutput_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Signals_TorqueConverterPumpTorqueOutput self, std::string const & key) -> Any
+        getDynamic(DriveTrain_Signals_TorqueConverterPumpTorqueOutput self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterPumpTorqueOutput_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterPumpTorqueOutput_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Signals_TorqueConverterPumpTorqueOutput self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_Signals_TorqueConverterPumpTorqueOutput self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -8401,62 +8401,62 @@ class Signals_TorqueConverterPumpTorqueOutput(openplx.Physics.Signals_Output):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterPumpTorqueOutput_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterPumpTorqueOutput_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Signals_TorqueConverterPumpTorqueOutput self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_Signals_TorqueConverterPumpTorqueOutput self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterPumpTorqueOutput_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterPumpTorqueOutput_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Signals_TorqueConverterPumpTorqueOutput self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_Signals_TorqueConverterPumpTorqueOutput self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterPumpTorqueOutput_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterPumpTorqueOutput_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Signals_TorqueConverterPumpTorqueOutput self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_Signals_TorqueConverterPumpTorqueOutput self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterPumpTorqueOutput_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_Signals_TorqueConverterPumpTorqueOutput
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterPumpTorqueOutput_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_Signals_TorqueConverterPumpTorqueOutput
 
-# Register Signals_TorqueConverterPumpTorqueOutput in _DriveTrainSwig:
-_DriveTrainSwig.Signals_TorqueConverterPumpTorqueOutput_swigregister(Signals_TorqueConverterPumpTorqueOutput)
+# Register DriveTrain_Signals_TorqueConverterPumpTorqueOutput in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_Signals_TorqueConverterPumpTorqueOutput_swigregister(DriveTrain_Signals_TorqueConverterPumpTorqueOutput)
 
-class Signals_TorqueConverterTurbineTorqueOutput(openplx.Physics.Signals_Output):
+class DriveTrain_Signals_TorqueConverterTurbineTorqueOutput(openplx.Physics.Physics_Signals_Output):
     r"""Proxy of C++ openplx::DriveTrain::Signals::TorqueConverterTurbineTorqueOutput class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(Signals_TorqueConverterTurbineTorqueOutput self) -> Signals_TorqueConverterTurbineTorqueOutput"""
-        _DriveTrainSwig.Signals_TorqueConverterTurbineTorqueOutput_swiginit(self, _DriveTrainSwig.new_Signals_TorqueConverterTurbineTorqueOutput())
+        r"""__init__(DriveTrain_Signals_TorqueConverterTurbineTorqueOutput self) -> DriveTrain_Signals_TorqueConverterTurbineTorqueOutput"""
+        _DriveTrainSwig.DriveTrain_Signals_TorqueConverterTurbineTorqueOutput_swiginit(self, _DriveTrainSwig.new_DriveTrain_Signals_TorqueConverterTurbineTorqueOutput())
 
     def torque_converter(self):
-        r"""torque_converter(Signals_TorqueConverterTurbineTorqueOutput self) -> std::shared_ptr< openplx::DriveTrain::EmpiricalTorqueConverter >"""
-        return _DriveTrainSwig.Signals_TorqueConverterTurbineTorqueOutput_torque_converter(self)
+        r"""torque_converter(DriveTrain_Signals_TorqueConverterTurbineTorqueOutput self) -> std::shared_ptr< openplx::DriveTrain::EmpiricalTorqueConverter >"""
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterTurbineTorqueOutput_torque_converter(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(Signals_TorqueConverterTurbineTorqueOutput self, std::string const & key, Any value)
+        setDynamic(DriveTrain_Signals_TorqueConverterTurbineTorqueOutput self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -8464,22 +8464,22 @@ class Signals_TorqueConverterTurbineTorqueOutput(openplx.Physics.Signals_Output)
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterTurbineTorqueOutput_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterTurbineTorqueOutput_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(Signals_TorqueConverterTurbineTorqueOutput self, std::string const & key) -> Any
+        getDynamic(DriveTrain_Signals_TorqueConverterTurbineTorqueOutput self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterTurbineTorqueOutput_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterTurbineTorqueOutput_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(Signals_TorqueConverterTurbineTorqueOutput self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_Signals_TorqueConverterTurbineTorqueOutput self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -8487,62 +8487,62 @@ class Signals_TorqueConverterTurbineTorqueOutput(openplx.Physics.Signals_Output)
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterTurbineTorqueOutput_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterTurbineTorqueOutput_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(Signals_TorqueConverterTurbineTorqueOutput self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_Signals_TorqueConverterTurbineTorqueOutput self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterTurbineTorqueOutput_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterTurbineTorqueOutput_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(Signals_TorqueConverterTurbineTorqueOutput self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_Signals_TorqueConverterTurbineTorqueOutput self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterTurbineTorqueOutput_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterTurbineTorqueOutput_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(Signals_TorqueConverterTurbineTorqueOutput self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_Signals_TorqueConverterTurbineTorqueOutput self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.Signals_TorqueConverterTurbineTorqueOutput_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_Signals_TorqueConverterTurbineTorqueOutput
+        return _DriveTrainSwig.DriveTrain_Signals_TorqueConverterTurbineTorqueOutput_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_Signals_TorqueConverterTurbineTorqueOutput
 
-# Register Signals_TorqueConverterTurbineTorqueOutput in _DriveTrainSwig:
-_DriveTrainSwig.Signals_TorqueConverterTurbineTorqueOutput_swigregister(Signals_TorqueConverterTurbineTorqueOutput)
+# Register DriveTrain_Signals_TorqueConverterTurbineTorqueOutput in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_Signals_TorqueConverterTurbineTorqueOutput_swigregister(DriveTrain_Signals_TorqueConverterTurbineTorqueOutput)
 
-class TorqueLimitedSlipDifferential(Differential):
+class DriveTrain_TorqueLimitedSlipDifferential(DriveTrain_Differential):
     r"""Proxy of C++ openplx::DriveTrain::TorqueLimitedSlipDifferential class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(TorqueLimitedSlipDifferential self) -> TorqueLimitedSlipDifferential"""
-        _DriveTrainSwig.TorqueLimitedSlipDifferential_swiginit(self, _DriveTrainSwig.new_TorqueLimitedSlipDifferential())
+        r"""__init__(DriveTrain_TorqueLimitedSlipDifferential self) -> DriveTrain_TorqueLimitedSlipDifferential"""
+        _DriveTrainSwig.DriveTrain_TorqueLimitedSlipDifferential_swiginit(self, _DriveTrainSwig.new_DriveTrain_TorqueLimitedSlipDifferential())
 
     def breakaway_torque(self):
-        r"""breakaway_torque(TorqueLimitedSlipDifferential self) -> double"""
-        return _DriveTrainSwig.TorqueLimitedSlipDifferential_breakaway_torque(self)
+        r"""breakaway_torque(DriveTrain_TorqueLimitedSlipDifferential self) -> double"""
+        return _DriveTrainSwig.DriveTrain_TorqueLimitedSlipDifferential_breakaway_torque(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(TorqueLimitedSlipDifferential self, std::string const & key, Any value)
+        setDynamic(DriveTrain_TorqueLimitedSlipDifferential self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -8550,22 +8550,22 @@ class TorqueLimitedSlipDifferential(Differential):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.TorqueLimitedSlipDifferential_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_TorqueLimitedSlipDifferential_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(TorqueLimitedSlipDifferential self, std::string const & key) -> Any
+        getDynamic(DriveTrain_TorqueLimitedSlipDifferential self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.TorqueLimitedSlipDifferential_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_TorqueLimitedSlipDifferential_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(TorqueLimitedSlipDifferential self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_TorqueLimitedSlipDifferential self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -8573,66 +8573,66 @@ class TorqueLimitedSlipDifferential(Differential):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.TorqueLimitedSlipDifferential_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_TorqueLimitedSlipDifferential_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(TorqueLimitedSlipDifferential self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_TorqueLimitedSlipDifferential self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.TorqueLimitedSlipDifferential_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_TorqueLimitedSlipDifferential_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(TorqueLimitedSlipDifferential self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_TorqueLimitedSlipDifferential self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.TorqueLimitedSlipDifferential_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_TorqueLimitedSlipDifferential_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(TorqueLimitedSlipDifferential self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_TorqueLimitedSlipDifferential self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.TorqueLimitedSlipDifferential_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_TorqueLimitedSlipDifferential
+        return _DriveTrainSwig.DriveTrain_TorqueLimitedSlipDifferential_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_TorqueLimitedSlipDifferential
 
-# Register TorqueLimitedSlipDifferential in _DriveTrainSwig:
-_DriveTrainSwig.TorqueLimitedSlipDifferential_swigregister(TorqueLimitedSlipDifferential)
+# Register DriveTrain_TorqueLimitedSlipDifferential in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_TorqueLimitedSlipDifferential_swigregister(DriveTrain_TorqueLimitedSlipDifferential)
 
-class TorqueMotor(openplx.Physics.Interactions_Interaction1DOF):
+class DriveTrain_TorqueMotor(openplx.Physics.Physics_Interactions_Interaction1DOF):
     r"""Proxy of C++ openplx::DriveTrain::TorqueMotor class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(TorqueMotor self) -> TorqueMotor"""
-        _DriveTrainSwig.TorqueMotor_swiginit(self, _DriveTrainSwig.new_TorqueMotor())
+        r"""__init__(DriveTrain_TorqueMotor self) -> DriveTrain_TorqueMotor"""
+        _DriveTrainSwig.DriveTrain_TorqueMotor_swiginit(self, _DriveTrainSwig.new_DriveTrain_TorqueMotor())
 
     def torque_input(self):
-        r"""torque_input(TorqueMotor self) -> std::shared_ptr< openplx::Physics::Signals::Torque1DInput >"""
-        return _DriveTrainSwig.TorqueMotor_torque_input(self)
+        r"""torque_input(DriveTrain_TorqueMotor self) -> std::shared_ptr< openplx::Physics::Signals::Torque1DInput >"""
+        return _DriveTrainSwig.DriveTrain_TorqueMotor_torque_input(self)
 
     def torque_output(self):
-        r"""torque_output(TorqueMotor self) -> std::shared_ptr< openplx::Physics::Signals::Torque1DOutput >"""
-        return _DriveTrainSwig.TorqueMotor_torque_output(self)
+        r"""torque_output(DriveTrain_TorqueMotor self) -> std::shared_ptr< openplx::Physics::Signals::Torque1DOutput >"""
+        return _DriveTrainSwig.DriveTrain_TorqueMotor_torque_output(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(TorqueMotor self, std::string const & key, Any value)
+        setDynamic(DriveTrain_TorqueMotor self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -8640,22 +8640,22 @@ class TorqueMotor(openplx.Physics.Interactions_Interaction1DOF):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.TorqueMotor_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_TorqueMotor_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(TorqueMotor self, std::string const & key) -> Any
+        getDynamic(DriveTrain_TorqueMotor self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.TorqueMotor_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_TorqueMotor_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(TorqueMotor self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_TorqueMotor self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -8663,66 +8663,66 @@ class TorqueMotor(openplx.Physics.Interactions_Interaction1DOF):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.TorqueMotor_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_TorqueMotor_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(TorqueMotor self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_TorqueMotor self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.TorqueMotor_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_TorqueMotor_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(TorqueMotor self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_TorqueMotor self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.TorqueMotor_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_TorqueMotor_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(TorqueMotor self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_TorqueMotor self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.TorqueMotor_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_TorqueMotor
+        return _DriveTrainSwig.DriveTrain_TorqueMotor_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_TorqueMotor
 
-# Register TorqueMotor in _DriveTrainSwig:
-_DriveTrainSwig.TorqueMotor_swigregister(TorqueMotor)
+# Register DriveTrain_TorqueMotor in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_TorqueMotor_swigregister(DriveTrain_TorqueMotor)
 
-class VelocityRatioGeometryFactorPair(openplx.Core.Object):
+class DriveTrain_VelocityRatioGeometryFactorPair(openplx.Core.Object):
     r"""Proxy of C++ openplx::DriveTrain::VelocityRatioGeometryFactorPair class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(VelocityRatioGeometryFactorPair self) -> VelocityRatioGeometryFactorPair"""
-        _DriveTrainSwig.VelocityRatioGeometryFactorPair_swiginit(self, _DriveTrainSwig.new_VelocityRatioGeometryFactorPair())
+        r"""__init__(DriveTrain_VelocityRatioGeometryFactorPair self) -> DriveTrain_VelocityRatioGeometryFactorPair"""
+        _DriveTrainSwig.DriveTrain_VelocityRatioGeometryFactorPair_swiginit(self, _DriveTrainSwig.new_DriveTrain_VelocityRatioGeometryFactorPair())
 
     def velocity_ratio(self):
-        r"""velocity_ratio(VelocityRatioGeometryFactorPair self) -> double"""
-        return _DriveTrainSwig.VelocityRatioGeometryFactorPair_velocity_ratio(self)
+        r"""velocity_ratio(DriveTrain_VelocityRatioGeometryFactorPair self) -> double"""
+        return _DriveTrainSwig.DriveTrain_VelocityRatioGeometryFactorPair_velocity_ratio(self)
 
     def geometry_factor(self):
-        r"""geometry_factor(VelocityRatioGeometryFactorPair self) -> double"""
-        return _DriveTrainSwig.VelocityRatioGeometryFactorPair_geometry_factor(self)
+        r"""geometry_factor(DriveTrain_VelocityRatioGeometryFactorPair self) -> double"""
+        return _DriveTrainSwig.DriveTrain_VelocityRatioGeometryFactorPair_geometry_factor(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(VelocityRatioGeometryFactorPair self, std::string const & key, Any value)
+        setDynamic(DriveTrain_VelocityRatioGeometryFactorPair self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -8730,22 +8730,22 @@ class VelocityRatioGeometryFactorPair(openplx.Core.Object):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.VelocityRatioGeometryFactorPair_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_VelocityRatioGeometryFactorPair_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(VelocityRatioGeometryFactorPair self, std::string const & key) -> Any
+        getDynamic(DriveTrain_VelocityRatioGeometryFactorPair self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.VelocityRatioGeometryFactorPair_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_VelocityRatioGeometryFactorPair_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(VelocityRatioGeometryFactorPair self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_VelocityRatioGeometryFactorPair self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -8753,66 +8753,66 @@ class VelocityRatioGeometryFactorPair(openplx.Core.Object):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.VelocityRatioGeometryFactorPair_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_VelocityRatioGeometryFactorPair_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(VelocityRatioGeometryFactorPair self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_VelocityRatioGeometryFactorPair self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.VelocityRatioGeometryFactorPair_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_VelocityRatioGeometryFactorPair_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(VelocityRatioGeometryFactorPair self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_VelocityRatioGeometryFactorPair self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.VelocityRatioGeometryFactorPair_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_VelocityRatioGeometryFactorPair_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(VelocityRatioGeometryFactorPair self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_VelocityRatioGeometryFactorPair self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.VelocityRatioGeometryFactorPair_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_VelocityRatioGeometryFactorPair
+        return _DriveTrainSwig.DriveTrain_VelocityRatioGeometryFactorPair_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_VelocityRatioGeometryFactorPair
 
-# Register VelocityRatioGeometryFactorPair in _DriveTrainSwig:
-_DriveTrainSwig.VelocityRatioGeometryFactorPair_swigregister(VelocityRatioGeometryFactorPair)
+# Register DriveTrain_VelocityRatioGeometryFactorPair in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_VelocityRatioGeometryFactorPair_swigregister(DriveTrain_VelocityRatioGeometryFactorPair)
 
-class VelocityRatioTorqueMultiplicationPair(openplx.Core.Object):
+class DriveTrain_VelocityRatioTorqueMultiplicationPair(openplx.Core.Object):
     r"""Proxy of C++ openplx::DriveTrain::VelocityRatioTorqueMultiplicationPair class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(VelocityRatioTorqueMultiplicationPair self) -> VelocityRatioTorqueMultiplicationPair"""
-        _DriveTrainSwig.VelocityRatioTorqueMultiplicationPair_swiginit(self, _DriveTrainSwig.new_VelocityRatioTorqueMultiplicationPair())
+        r"""__init__(DriveTrain_VelocityRatioTorqueMultiplicationPair self) -> DriveTrain_VelocityRatioTorqueMultiplicationPair"""
+        _DriveTrainSwig.DriveTrain_VelocityRatioTorqueMultiplicationPair_swiginit(self, _DriveTrainSwig.new_DriveTrain_VelocityRatioTorqueMultiplicationPair())
 
     def velocity_ratio(self):
-        r"""velocity_ratio(VelocityRatioTorqueMultiplicationPair self) -> double"""
-        return _DriveTrainSwig.VelocityRatioTorqueMultiplicationPair_velocity_ratio(self)
+        r"""velocity_ratio(DriveTrain_VelocityRatioTorqueMultiplicationPair self) -> double"""
+        return _DriveTrainSwig.DriveTrain_VelocityRatioTorqueMultiplicationPair_velocity_ratio(self)
 
     def multiplier(self):
-        r"""multiplier(VelocityRatioTorqueMultiplicationPair self) -> double"""
-        return _DriveTrainSwig.VelocityRatioTorqueMultiplicationPair_multiplier(self)
+        r"""multiplier(DriveTrain_VelocityRatioTorqueMultiplicationPair self) -> double"""
+        return _DriveTrainSwig.DriveTrain_VelocityRatioTorqueMultiplicationPair_multiplier(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(VelocityRatioTorqueMultiplicationPair self, std::string const & key, Any value)
+        setDynamic(DriveTrain_VelocityRatioTorqueMultiplicationPair self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -8820,22 +8820,22 @@ class VelocityRatioTorqueMultiplicationPair(openplx.Core.Object):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.VelocityRatioTorqueMultiplicationPair_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_VelocityRatioTorqueMultiplicationPair_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(VelocityRatioTorqueMultiplicationPair self, std::string const & key) -> Any
+        getDynamic(DriveTrain_VelocityRatioTorqueMultiplicationPair self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.VelocityRatioTorqueMultiplicationPair_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_VelocityRatioTorqueMultiplicationPair_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(VelocityRatioTorqueMultiplicationPair self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_VelocityRatioTorqueMultiplicationPair self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -8843,62 +8843,62 @@ class VelocityRatioTorqueMultiplicationPair(openplx.Core.Object):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.VelocityRatioTorqueMultiplicationPair_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_VelocityRatioTorqueMultiplicationPair_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(VelocityRatioTorqueMultiplicationPair self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_VelocityRatioTorqueMultiplicationPair self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.VelocityRatioTorqueMultiplicationPair_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_VelocityRatioTorqueMultiplicationPair_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(VelocityRatioTorqueMultiplicationPair self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_VelocityRatioTorqueMultiplicationPair self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.VelocityRatioTorqueMultiplicationPair_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_VelocityRatioTorqueMultiplicationPair_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(VelocityRatioTorqueMultiplicationPair self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_VelocityRatioTorqueMultiplicationPair self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.VelocityRatioTorqueMultiplicationPair_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_VelocityRatioTorqueMultiplicationPair
+        return _DriveTrainSwig.DriveTrain_VelocityRatioTorqueMultiplicationPair_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_VelocityRatioTorqueMultiplicationPair
 
-# Register VelocityRatioTorqueMultiplicationPair in _DriveTrainSwig:
-_DriveTrainSwig.VelocityRatioTorqueMultiplicationPair_swigregister(VelocityRatioTorqueMultiplicationPair)
+# Register DriveTrain_VelocityRatioTorqueMultiplicationPair in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_VelocityRatioTorqueMultiplicationPair_swigregister(DriveTrain_VelocityRatioTorqueMultiplicationPair)
 
-class ViscousGear(Gear):
+class DriveTrain_ViscousGear(DriveTrain_Gear):
     r"""Proxy of C++ openplx::DriveTrain::ViscousGear class."""
 
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
     def __init__(self):
-        r"""__init__(ViscousGear self) -> ViscousGear"""
-        _DriveTrainSwig.ViscousGear_swiginit(self, _DriveTrainSwig.new_ViscousGear())
+        r"""__init__(DriveTrain_ViscousGear self) -> DriveTrain_ViscousGear"""
+        _DriveTrainSwig.DriveTrain_ViscousGear_swiginit(self, _DriveTrainSwig.new_DriveTrain_ViscousGear())
 
     def dissipation(self):
-        r"""dissipation(ViscousGear self) -> std::shared_ptr< openplx::Physics::Interactions::Dissipation::ConstantViscousSurfaceFriction >"""
-        return _DriveTrainSwig.ViscousGear_dissipation(self)
+        r"""dissipation(DriveTrain_ViscousGear self) -> std::shared_ptr< openplx::Physics::Interactions::Dissipation::ConstantViscousSurfaceFriction >"""
+        return _DriveTrainSwig.DriveTrain_ViscousGear_dissipation(self)
 
     def setDynamic(self, key, value):
         r"""
-        setDynamic(ViscousGear self, std::string const & key, Any value)
+        setDynamic(DriveTrain_ViscousGear self, std::string const & key, Any value)
 
         Parameters
         ----------
@@ -8906,22 +8906,22 @@ class ViscousGear(Gear):
         value: openplx::Core::Any &&
 
         """
-        return _DriveTrainSwig.ViscousGear_setDynamic(self, key, value)
+        return _DriveTrainSwig.DriveTrain_ViscousGear_setDynamic(self, key, value)
 
     def getDynamic(self, key):
         r"""
-        getDynamic(ViscousGear self, std::string const & key) -> Any
+        getDynamic(DriveTrain_ViscousGear self, std::string const & key) -> Any
 
         Parameters
         ----------
         key: std::string const &
 
         """
-        return _DriveTrainSwig.ViscousGear_getDynamic(self, key)
+        return _DriveTrainSwig.DriveTrain_ViscousGear_getDynamic(self, key)
 
     def callDynamic(self, key, args):
         r"""
-        callDynamic(ViscousGear self, std::string const & key, AnyVector args) -> Any
+        callDynamic(DriveTrain_ViscousGear self, std::string const & key, AnyVector args) -> Any
 
         Parameters
         ----------
@@ -8929,44 +8929,44 @@ class ViscousGear(Gear):
         args: std::vector< openplx::Core::Any,std::allocator< openplx::Core::Any > > const &
 
         """
-        return _DriveTrainSwig.ViscousGear_callDynamic(self, key, args)
+        return _DriveTrainSwig.DriveTrain_ViscousGear_callDynamic(self, key, args)
 
     def extractObjectFieldsTo(self, output):
         r"""
-        extractObjectFieldsTo(ViscousGear self, ObjectVector output)
+        extractObjectFieldsTo(DriveTrain_ViscousGear self, ObjectVector output)
 
         Parameters
         ----------
         output: std::vector< std::shared_ptr< openplx::Core::Object >,std::allocator< std::shared_ptr< openplx::Core::Object > > > &
 
         """
-        return _DriveTrainSwig.ViscousGear_extractObjectFieldsTo(self, output)
+        return _DriveTrainSwig.DriveTrain_ViscousGear_extractObjectFieldsTo(self, output)
 
     def extractEntriesTo(self, output):
         r"""
-        extractEntriesTo(ViscousGear self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
+        extractEntriesTo(DriveTrain_ViscousGear self, std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > & output)
 
         Parameters
         ----------
         output: std::vector< std::pair< std::string,openplx::Core::Any >,std::allocator< std::pair< std::string,openplx::Core::Any > > > &
 
         """
-        return _DriveTrainSwig.ViscousGear_extractEntriesTo(self, output)
+        return _DriveTrainSwig.DriveTrain_ViscousGear_extractEntriesTo(self, output)
 
     def triggerOnInit(self, context):
         r"""
-        triggerOnInit(ViscousGear self, openplx::RuntimeContext const & context)
+        triggerOnInit(DriveTrain_ViscousGear self, openplx::RuntimeContext const & context)
 
         Parameters
         ----------
         context: openplx::RuntimeContext const &
 
         """
-        return _DriveTrainSwig.ViscousGear_triggerOnInit(self, context)
-    __swig_destroy__ = _DriveTrainSwig.delete_ViscousGear
+        return _DriveTrainSwig.DriveTrain_ViscousGear_triggerOnInit(self, context)
+    __swig_destroy__ = _DriveTrainSwig.delete_DriveTrain_ViscousGear
 
-# Register ViscousGear in _DriveTrainSwig:
-_DriveTrainSwig.ViscousGear_swigregister(ViscousGear)
+# Register DriveTrain_ViscousGear in _DriveTrainSwig:
+_DriveTrainSwig.DriveTrain_ViscousGear_swigregister(DriveTrain_ViscousGear)