Feature migration to gymnasium

.gitignore

@@ -30,3 +30,5 @@ examples/logs/
 /my_examples/
 .vscode/settings.json
 .vscode/launch.json
+
+plots/

README.md

@@ -38,7 +38,6 @@ if __name__ == '__main__':
     env = gem.make("Finite-CC-PMSM-v0")  # instantiate a discretely controlled PMSM
     env.reset()
     for _ in range(10000):
-        env.render()  # visualize environment
         (states, references), rewards, done, _ =\ 
         	env.step(env.action_space.sample())  # pick random control actions
         if done:

examples/classic_controllers/classic_controllers.py

@@ -1,4 +1,4 @@
-from gym.spaces import Discrete, Box, MultiDiscrete
+from gymnasium.spaces import Discrete, Box, MultiDiscrete
 from gym_electric_motor.physical_systems import SynchronousMotorSystem, DcMotorSystem, DcSeriesMotor, \
     DcExternallyExcitedMotor, DoublyFedInductionMotorSystem, SquirrelCageInductionMotorSystem
 from gym_electric_motor.reference_generators import MultipleReferenceGenerator, SwitchedReferenceGenerator
@@ -347,27 +347,52 @@ def automated_gain(environment, stages, controller_type, _controllers, **control
             elif _controllers[controller_type][0] == CascadedController:
 
                 for i in range(len(stages)):
-                    if _controllers[stages_a[i]['controller_type']][1] == ContinuousController:
-
-                        if i == 0:
-                            p_gain = mp['l'] / (environment.physical_system.tau * a) / u_a_lim * i_a_lim
-                            i_gain = p_gain / (environment.physical_system.tau * a ** 2)
-
-                            if _controllers[stages_a[i]['controller_type']][2] == PIDController:
-                                d_gain = p_gain * environment.physical_system.tau
-                                stages_a[i]['d_gain'] = stages_a[i].get('d_gain', d_gain)
-
-                        elif i == 1:
-                            t_n = environment.physical_system.tau * a ** 2
-                            p_gain = environment.physical_system.mechanical_load.j_total / (
-                                    a * t_n) / i_a_lim * omega_lim
-                            i_gain = p_gain / (a * t_n)
-                            if _controllers[stages_a[i]['controller_type']][2] == PIDController:
-                                d_gain = p_gain * environment.physical_system.tau
-                                stages_a[i]['d_gain'] = stages_a[i].get('d_gain', d_gain)
-
-                        stages_a[i]['p_gain'] = stages_a[i].get('p_gain', p_gain)
-                        stages_a[i]['i_gain'] = stages_a[i].get('i_gain', i_gain)
+                    if type(stages_a[i]) is list:
+                        if _controllers[stages_a[i][0]['controller_type']][1] == ContinuousController: #had to add [0] to make dict in list acessable
+
+                            if i == 0:
+                                p_gain = mp['l'] / (environment.physical_system.tau * a) / u_a_lim * i_a_lim
+                                i_gain = p_gain / (environment.physical_system.tau * a ** 2)
+
+                                if _controllers[stages_a[i][0]['controller_type']][2] == PIDController:
+                                    d_gain = p_gain * environment.physical_system.tau
+                                    stages_a[i][0]['d_gain'] = stages_a[i][0].get('d_gain', d_gain)
+
+                            elif i == 1:
+                                t_n = environment.physical_system.tau * a ** 2
+                                p_gain = environment.physical_system.mechanical_load.j_total / (
+                                        a * t_n) / i_a_lim * omega_lim
+                                i_gain = p_gain / (a * t_n)
+                                if _controllers[stages_a[i][0]['controller_type']][2] == PIDController:
+                                    d_gain = p_gain * environment.physical_system.tau
+                                    stages_a[i][0]['d_gain'] = stages_a[i][0].get('d_gain', d_gain)
+
+                            stages_a[i][0]['p_gain'] = stages_a[i][0].get('p_gain', p_gain)#?
+                            stages_a[i][0]['i_gain'] = stages_a[i][0].get('i_gain', i_gain)#?
+
+                    elif type(stages_a[i]) is dict:
+                        if _controllers[stages_a[i]['controller_type']][1] == ContinuousController: #had to add [0] to make dict in list acessable
+
+                            if i == 0:
+                                p_gain = mp['l'] / (environment.physical_system.tau * a) / u_a_lim * i_a_lim
+                                i_gain = p_gain / (environment.physical_system.tau * a ** 2)
+
+                                if _controllers[stages_a[i]['controller_type']][2] == PIDController:
+                                    d_gain = p_gain * environment.physical_system.tau
+                                    stages_a[i]['d_gain'] = stages_a[i].get('d_gain', d_gain)
+
+                            elif i == 1:
+                                t_n = environment.physical_system.tau * a ** 2
+                                p_gain = environment.physical_system.mechanical_load.j_total / (
+                                        a * t_n) / i_a_lim * omega_lim
+                                i_gain = p_gain / (a * t_n)
+                                if _controllers[stages_a[i]['controller_type']][2] == PIDController:
+                                    d_gain = p_gain * environment.physical_system.tau
+                                    stages_a[i]['d_gain'] = stages_a[i].get('d_gain', d_gain)
+
+                            stages_a[i]['p_gain'] = stages_a[i].get('p_gain', p_gain)#?
+                            stages_a[i]['i_gain'] = stages_a[i].get('i_gain', i_gain)#?
+
 
                 stages = stages_a if not stages_e else [stages_a, stages_e]
 

examples/classic_controllers/classic_controllers_dc_motor_example.py

@@ -38,29 +38,27 @@
     external_ref_plots = [ExternallyReferencedStatePlot(state) for state in states]
 
     # initialize the gym-electric-motor environment
-    env = gem.make(motor, visualization=MotorDashboard(additional_plots=external_ref_plots))
-
+    env = gem.make(motor, visualization=MotorDashboard(additional_plots=external_ref_plots), render_mode="figure_once")
     """
         initialize the controller
 
         Args:
             environment                     gym-electric-motor environment
             external_ref_plots (optional)   plots of the environment, to plot all reference values
             stages (optional)               structure of the controller
-            automated_gain (optional)       if True (default), the controller will be tune automatically
+            automated_gain (optional)       if True (default), the controller will be tuned automatically
             a (optional)                    tuning parameter of the symmetrical optimum (default: 4)
 
     """
+    visualization = MotorDashboard(additional_plots=external_ref_plots)
     controller = Controller.make(env, external_ref_plots=external_ref_plots)
 
-    state, reference = env.reset()
-
+    state, reference = env.reset(seed = None)
     # simulate the environment
     for i in range(10001):
         action = controller.control(state, reference)
-        env.render()
-        (state, reference), reward, done, _ = env.step(action)
-        if done:
+        (state, reference), reward, terminated, truncated, _ = env.step(action)
+        if terminated:
             env.reset()
             controller.reset()
 

examples/classic_controllers/classic_controllers_ind_motor_example.py

@@ -50,10 +50,9 @@
 
     # simulate the environment
     for i in range(10001):
-        env.render()
         action = controller.control(state, reference)
-        (state, reference), reward, done, _ = env.step(action)
-        if done:
+        (state, reference), reward, terminated, truncated, _ = env.step(action)
+        if terminated:
             env.reset()
             controller.reset()
     env.close()

examples/classic_controllers/classic_controllers_synch_motor_example.py

@@ -54,10 +54,9 @@
 
     # simulate the environment
     for i in range(10001):
-        env.render()
         action = controller.control(state, reference)
-        (state, reference), reward, done, _ = env.step(action)
-        if done:
+        (state, reference), reward, terminated, truncated, _ = env.step(action)
+        if terminated:
             env.reset()
             controller.reset()
 

examples/classic_controllers/controllers/cascaded_controller.py

@@ -1,5 +1,5 @@
 from .continuous_controller import ContinuousController
-from gym.spaces import Box, Discrete, MultiDiscrete
+from gymnasium.spaces import Box, Discrete, MultiDiscrete
 from gym_electric_motor.physical_systems import DcExternallyExcitedMotor
 from .plot_external_data import plot
 
@@ -16,6 +16,7 @@ class CascadedController:
 
     def __init__(self, environment, stages, _controllers, visualization, ref_states, external_ref_plots=(), **controller_kwargs):
 
+        self.env = environment
         self.visualization = visualization
         self.action_space = environment.action_space
         self.state_space = environment.physical_system.state_space
@@ -171,9 +172,10 @@ def control(self, state, reference):
             else:
                 action = np.array([action, action_u_e], dtype='object')
 
-        # Plot the external references
-        plot(external_reference_plots=self.external_ref_plots, state_names=self.state_names,
-             visualization=self.visualization, external_data=self.get_plot_data())
+        if self.env.render_mode != None:
+            # Plot the external references
+            plot(external_reference_plots=self.external_ref_plots, state_names=self.state_names,
+                visualization=self.visualization, external_data=self.get_plot_data())
 
         return action
 

examples/classic_controllers/controllers/cascaded_foc_controller.py

@@ -1,7 +1,7 @@
 from .continuous_controller import ContinuousController
 from .torque_to_current_conversion import TorqueToCurrentConversion
 from .plot_external_data import plot
-from gym.spaces import Box
+from gymnasium.spaces import Box
 import numpy as np
 
 
@@ -53,7 +53,7 @@ def __init__(self,  environment, stages, _controllers, ref_states, external_ref_
 
         self.mp = environment.physical_system.electrical_motor.motor_parameter
         self.psi_p = self.mp.get('psi_p', 0)
-        self.dead_time = 1.5 if environment.physical_system.converter._dead_time else 0.5
+        self.dead_time = 0.5
         self.decoupling = controller_kwargs.get('decoupling', True)
 
         self.ref_state_idx = [self.i_sq_idx, self.i_sd_idx]

examples/classic_controllers/controllers/continuous_action_controller.py

@@ -1,4 +1,4 @@
-from gym.spaces import Box
+from gymnasium.spaces import Box
 from gym_electric_motor.physical_systems import DcMotorSystem, DcExternallyExcitedMotor
 from .plot_external_data import plot
 import numpy as np

examples/classic_controllers/controllers/dicrete_action_controller.py

@@ -1,5 +1,5 @@
 from .plot_external_data import plot
-from gym.spaces import Discrete, MultiDiscrete
+from gymnasium.spaces import Discrete, MultiDiscrete
 from gym_electric_motor.physical_systems import DcMotorSystem, DcExternallyExcitedMotor
 import numpy as np
 

examples/classic_controllers/controllers/discrete_controller.py

@@ -1,4 +1,4 @@
-from gym.spaces import Discrete, MultiDiscrete
+from gymnasium.spaces import Discrete, MultiDiscrete
 
 
 class DiscreteController:

examples/classic_controllers/controllers/foc_controller.py

@@ -1,6 +1,6 @@
 from .plot_external_data import plot
 from gym_electric_motor.physical_systems import SynchronousMotorSystem
-from gym.spaces import Box
+from gymnasium.spaces import Box
 import numpy as np
 
 

examples/classic_controllers/controllers/induction_motor_cascaded_foc.py

@@ -2,7 +2,7 @@
 from .induction_motor_torque_to_current_conversion import InductionMotorTorqueToCurrentConversion
 from .flux_observer import FluxObserver
 from .plot_external_data import plot
-from gym.spaces import Box
+from gymnasium.spaces import Box
 import numpy as np
 
 

examples/classic_controllers/controllers/induction_motor_foc.py

@@ -1,6 +1,6 @@
 from .flux_observer import FluxObserver
 from .plot_external_data import plot
-from gym.spaces import Box
+from gymnasium.spaces import Box
 import numpy as np
 
 

examples/classic_controllers/controllers/torque_to_current_conversion.py

@@ -10,12 +10,12 @@ class TorqueToCurrentConversion:
         This class represents the torque controller for cascaded control of synchronous motors.  For low speeds only the
         current limitation of the motor is important. The current vector to set a desired torque is selected so that the
         amount of the current vector is minimum (Maximum Torque per Current). For higher speeds, the voltage limitation
-        of the synchronous motor or the actuator must also be taken into account. This is done by converting the
+        of the synchronous motor or the actuator must also be taken into account. This is terminated by converting the
         available voltage to a speed-dependent maximum flux. An additional modulation controller is used for the flux
         control. By limiting the flux and the maximum torque per flux (MTPF), an operating point for the flux and the
-        torque is obtained. This is then converted into a current operating point. The conversion can be done by
+        torque is obtained. This is then converted into a current operating point. The conversion can be terminated by
         different methods (parameter torque_control). On the one hand, maps can be determined in advance by
-        interpolation or analytically, or the analytical determination can be done online.
+        interpolation or analytically, or the analytical determination can be terminated online.
         For the visualization of the operating points, both for the current operating points as well as the flux and
         torque operating points, predefined plots are available (plot_torque: default True). Also the values of the
         modulation controller can be visualized (plot_modulation: default False).

examples/classic_controllers/custom_classic_controllers_dc_motor_example.py

@@ -39,7 +39,7 @@
     external_ref_plots = [ExternallyReferencedStatePlot(state) for state in states]
 
     # initialize the gym-electric-motor environment
-    env = gem.make(motor, visualization=MotorDashboard(additional_plots=external_ref_plots))
+    env = gem.make(motor, visualization=MotorDashboard(additional_plots=external_ref_plots), render_mode = 'figure')
 
     """
         initialize the controller
@@ -74,9 +74,8 @@
     # simulate the environment
     for i in range(10001):
         action = controller.control(state, reference)
-        env.render()
-        (state, reference), reward, done, _ = env.step(action)
-        if done:
+        (state, reference), reward, terminated, truncated, _ = env.step(action)
+        if terminated:
             env.reset()
             controller.reset()
 

examples/classic_controllers/custom_classic_controllers_ind_motor_example.py

@@ -53,10 +53,9 @@
 
     # simulate the environment
     for i in range(10001):
-        env.render()
         action = controller.control(state, reference)
-        (state, reference), reward, done, _ = env.step(action)
-        if done:
+        (state, reference), reward, terminated, truncated, _ = env.step(action)
+        if terminated:
             env.reset()
             controller.reset()
     env.close()

examples/classic_controllers/custom_classic_controllers_synch_motor_example.py

@@ -35,7 +35,8 @@
 
     # initialize the gym-electric-motor environment
     env = gem.make(env_id, visualization=MotorDashboard(additional_plots=external_ref_plots),
-                   motor=dict(limit_values=limit_values, nominal_values=nominal_values, motor_parameter=motor_parameter))
+                   motor=dict(limit_values=limit_values, nominal_values=nominal_values, motor_parameter=motor_parameter),
+                   render_mode = 'figure')
 
     """
     initialize the controller
@@ -104,10 +105,9 @@
 
     # simulate the environment
     for i in range(10001):
-        env.render()
         action = controller.control(state, reference)
-        (state, reference), reward, done, _ = env.step(action)
-        if done:
+        (state, reference), reward, terminated, truncated, _ = env.step(action)
+        if terminated:
             env.reset()
             controller.reset()
 

examples/classic_controllers/external_plot.py

@@ -25,14 +25,13 @@ class ExternalPlot(TimePlot):
             >>>     # setting the labels of the plots
             >>>     external_plot.set_label({'y_label': 'y', 'state_label': '$state$', 'ref_label': '$reference$',
             ...                             'add_label': ['$add_1$', '$add_2$']})
-            >>>     done = True
+            >>>     terminated = True
             >>>     for t in range(100000):
-            >>>     if done:
+            >>>     if terminated:
             >>>         state, reference = env.reset()
-            >>>     env.render()
             >>>     data = [np.sin(t / 500), np.sin(t / 1000), np.sin(t / 1500), np.sin(t / 2000)]
             >>>     external_plot.add_data(data) # passing the data to the external plot
-            >>>     (state, reference), reward, done, _ = env.step([0, 0])
+            >>>     (state, reference), reward, terminated, truncated, _ = env.step([0, 0])
     """
 
     def __init__(self, referenced=False, additional_lines=0, min=0, max=1):
@@ -111,7 +110,7 @@ def initialize(self, axis):
         # If the state is referenced plot also the reference line
         if self._referenced:
             self._reference_line, = self._axis.plot(self._x_data, self._reference_data, **self._ref_line_config, zorder=self.add_lines+1)
-            axis.lines = axis.lines[::-1]
+            #axis.lines = axis.lines[::-1]
             self._lines.append(self._reference_line)
 
         self._y_data = [self._state_data, self._reference_data]
@@ -149,8 +148,8 @@ def set_label(self, labels):
         if 'add_label' in labels.keys():
             self.add_labels = labels['add_label']
 
-    def on_step_end(self, k, state, reference, reward, done):
-        super().on_step_end(k, state, reference, reward, done)
+    def on_step_end(self, k, state, reference, reward, terminated):
+        super().on_step_end(k, state, reference, reward, terminated)
         idx = self.data_idx
         self._x_data[idx] = self._t
 

examples/classic_controllers/externally_referenced_state_plot.py

@@ -13,15 +13,14 @@ class ExternallyReferencedStatePlot(StatePlot):
                     'DqCont-SC-PMSM-v0',
                     visualization=dict(additional_plots=(my_externally_referenced_plot,),
                 )
-                done = True
+                terminated = True
                 for _ in range(10000):
-                    if done:
+                    if terminated:
                         state, reference = env.reset()
                     external_reference_value = my_external_isd_reference_generator.get_reference()
                     my_externally_referenced_plot.external_reference(external_reference_value)
-                    env.render()
                     action = env.action_space.sample()
-                    (state, reference), reward, done, _ = env.step(action)
+                    (state, reference), reward, terminated, truncated, _ = env.step(action)
     """
 
     def __init__(self, state):