Environments

On this page, all environments with their environment-id are listed. In general, all environment-ids are structured as follows:

ControlType-ControlTask-MotorType-v0

  • The ControlType is in {Finite / Cont} for finite control set and continuous control set action spaces

  • The ControlTask is in {TC / SC / CC} (Torque / Speed / Current Control)

  • The MotorType is in {PermExDc / ExtExDc / SeriesDc / ShuntDc / PMSM / SynRM / / EESM / DFIM / SCIM / SIXPMSM }

Motor Environments:

Electric Motor Base Environment

On the core level the electric motor environment and the interface to its submodules are defined. By using these interfaces further reference generators, reward functions, visualizations or physical models can be implemented.

Each ElectricMotorEnvironment contains the five following modules:

  • PhysicalSystem

    • Specification and simulation of the physical model. Furthermore, specifies limits and nominal values for all of its state_variables.

  • ReferenceGenerator

    • Calculation of reference trajectories for one or more states of the physical systems state_variables.

  • ConstraintMonitor

    • Observation of the PhysicalSystems state to comply to a set of user defined constraints.

  • RewardFunction

    • Calculation of the reward based on the physical systems state and the reference.* ElectricMotorVisualization

    • Visualization of the PhysicalSystems state, reference and reward for the user.

../../_images/TopLevelStructure.svg
class gym_electric_motor.core.ElectricMotorEnvironment(physical_system, reference_generator, reward_function, visualization=(), state_filter=None, callbacks=(), constraints=(), physical_system_wrappers=(), scale_plots=False, **kwargs)[source]
Description:

The main class connecting all modules of the gym-electric-motor environments.

Modules:

Physical System:

Containing the physical structure and simulation of the drive system as well as information about the technical limits and nominal values. Needs to be a subclass of PhysicalSystem

Reference Generator:

Generation of the reference for the motor to follow. Needs to be a subclass of ReferenceGenerator

Reward Function:

Calculation of the reward based on the state of the physical system and the generated reference and observation if the motor state is within the limits. Needs to be a subclass of RewardFunction.

Visualization:

Visualization of the motors states. Needs to be a subclass of ElectricMotorVisualization

Limits:

Returns a list of limits of all states in the observation (called in state_filter) in the same order.

State Variables:

Each environment has got a list of state variables that are defined by the physical system. These define the names and order for all further state arrays in the modules. These states are announced to the other modules by announcing the physical system to them, which contains the property state_names.

Example:

['omega', 'torque','i', 'u', 'u_sup']

Observation:
Type: Tuple(State_Space, Reference_Space)

The observation is always a tuple of the State Space of the Physical System and the Reference Space of the Reference Generator. In all current Physical Systems and Reference Generators these Spaces are normalized, continuous, multidimensional boxes in [-1, 1] or [0, 1].

Actions:
Type: Discrete() / Box()

The action space of the environments are the action spaces of the physical systems. In all current physical systems the action spaces are specified by its PowerElectronicConverter and either a continuous, multidimensional box or discrete.

Reward:

The reward and the reward range are specified by the RewardFunction. In general the reward is higher the closer the motor state follows the reference trajectories.

Starting State:

The physical system and the reference generator define the starting state.

Episode Termination:

Episode terminations can be initiated by the reference generator, or the reward function. A reference generator might terminate an episode, if the reference has ended. The reward function can terminate an episode, if a physical limit of the motor has been violated.

Setting and initialization of all environments’ modules.

Parameters:

  • physical_system (PhysicalSystem) – The physical system of this environment.

  • reference_generator (ReferenceGenerator) – The reference generator of this environment.

  • reward_function (RewardFunction) – The reward function of this environment.

  • visualization (iterable(ElectricMotorVisualization)/None) – The visualization of this environment.

  • constraints (list(Constraint/str/callable) / ConstraintMonitor) –

    A list of constraints or an already initialized ConstraintMonitor object can be passed here.

    • list(Constraint/str/callable): Pass a list with initialized Constraints and/or state names. Then,

    a ConstraintMonitor object with the Constraints and additional LimitConstraints on the passed names is created. Furthermore, the string ‘all’ inside the list will create a ConstraintMonitor that observes the limit on each state. - ConstraintMonitor: Pass an initialized ConstraintMonitor object that will be used directly as

    ConstraintMonitor in the environment.

  • visualization – The visualizations of this environment.

  • state_filter (list(str)) – Selection of states that are shown in the observation.

  • physical_system_wrappers (iterable(PhysicalSystemWrapper)) – PhysicalSystemWrapper instances to be wrapped around the physical system.

  • callbacks (list(Callback)) – Callbacks being called in the environment

  • **kwargs – Arguments to be passed to the modules.

close()[source]

Called when the environment is deleted. Closes all its modules.

property constraint_monitor

The ConstraintMonitor of the environment.

Type:

Returns(ConstraintMonitor)

property limits

Returns a list of limits of all states in the observation (called in state_filter) in the same order

property nominal_state

Returns a list of nominal values of all states in the observation (called in state_filter) in that order

property physical_system

Returns: PhysicalSystem: The Physical System of the Environment

property reference_generator

Returns: ReferenceGenerator: The ReferenceGenerator of the Environment

property reference_names

Returns a list of state names of all states in the observation (called in state_filter) in the same order

render(*_, **__)[source]

Update the visualization of the motor.

reset(seed=None, options=None, *_, **__)[source]

Reset of the environment and all its modules to an initial state.

Returns:

The initial observation consisting of the initial state and initial reference. info(dict): Auxiliary information (optional)

property reward_function

Returns: RewardFunction: The RewardFunction of the environment

property state_names

Returns a list of state names of all states in the observation (called in state_filter) in the same order

step(action)[source]

Perform one simulation step of the environment with an action of the action space.

Parameters:

action – Action to play on the environment.

Returns:

Tuple of the new state and the next reference. reward(float): Amount of reward received for the last step. terminated(bool): Flag, indicating if a reset is required before new steps can be taken. info(dict): Auxiliary information (optional)

Return type:

observation(Tuple(ndarray(float),ndarray(float))

property visualizations

Returns a list of all active motor visualizations.