/
BaseVoltageController.py
138 lines (106 loc) · 4.88 KB
/
BaseVoltageController.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
# Copyright (c) 2019-2020, RTE (https://www.rte-france.com)
# See AUTHORS.txt
# This Source Code Form is subject to the terms of the Mozilla Public License, version 2.0.
# If a copy of the Mozilla Public License, version 2.0 was not distributed with this file,
# you can obtain one at http://mozilla.org/MPL/2.0/.
# SPDX-License-Identifier: MPL-2.0
# This file is part of Grid2Op, Grid2Op a testbed platform to model sequential decision making in power systems.
from abc import ABC, abstractmethod
import numpy as np
import copy
from grid2op.dtypes import dt_int
from grid2op.Action import VoltageOnlyAction, ActionSpace
from grid2op.Rules import AlwaysLegal
from grid2op.Space import RandomObject
class BaseVoltageController(RandomObject, ABC):
"""
This class is the most basic controler for the voltages. Basically, what it does is read the voltages from the
chronics.
If the voltages are not on the chronics (missing files), it will not change the voltage setpoints at all.
"""
def __init__(self, gridobj, controler_backend, actionSpace_cls):
"""
Parameters
----------
gridobj: :class:`grid2op.Space.Gridobject`
Structure of the powergrid
controler_backend: :class:`grid2op.Backend.Backend`
An instanciated backend to perform some computation on a powergrid, before taking some actions.
"""
RandomObject.__init__(self)
legal_act = AlwaysLegal()
self._actionSpace_cls = actionSpace_cls
self.action_space = actionSpace_cls(
gridobj=gridobj, actionClass=VoltageOnlyAction, legal_action=legal_act
)
def _custom_deepcopy_for_copy(self, new_obj):
RandomObject._custom_deepcopy_for_copy(self, new_obj)
new_obj._actionSpace_cls = self._actionSpace_cls
legal_act = AlwaysLegal()
new_obj.action_space = new_obj._actionSpace_cls(
gridobj=self._actionSpace_cls,
actionClass=VoltageOnlyAction,
legal_action=legal_act,
)
def copy(self):
"""
INTERNAL
.. warning:: /!\\\\ Internal, do not use unless you know what you are doing /!\\\\
Make a (deep) copy of this instance.
"""
res = type(self).__new__(type(self))
self._custom_deepcopy_for_copy(res)
return res
def attach_layout(self, grid_layout):
"""
INTERNAL
.. warning:: /!\\\\ Internal, do not use unless you know what you are doing /!\\\\
"""
self.action_space.attach_layout(grid_layout)
def seed(self, seed):
"""
Used to seed the voltage controler class
.. warning:: /!\\\\ Internal, do not use unless you know what you are doing /!\\\\
"""
me_seed = super().seed(seed)
max_int = np.iinfo(dt_int).max
seed_space = self.space_prng.randint(max_int)
space_seed = self.action_space.seed(seed_space)
return me_seed, space_seed
@abstractmethod
def fix_voltage(self, observation, agent_action, env_action, prod_v_chronics):
"""
This method must be overloaded to change the behaviour of the generator setpoint for time t+1.
This simple class will:
- do nothing if the vector `prod_v_chronics` is None
- set the generator setpoint to the value in prod_v_chronics
Basically, this class is pretty fast, but does nothing interesting, beside looking at the data in files.
More general class can use, to adapt the voltage setpoint:
- `observation` the observation (receive by the agent) at time t
- `agent_action` the action of the agent at time t
- `env_action` the modification of the environment at time t, that will be observed by the agent at time
t+1
- `prod_v_chronics` the new setpoint of the generators present in the data (if any, this can be None)
To help this class, a :class:`grid2op.Backend.Backend` is available and can be used to perform simulation of
potential impact of voltages setpoints.
Parameters
----------
observation: :class:`grid2op.Observation.Observation`
The last observation (at time t)
agent_action: :class:`grid2op.Action.Action`
The action that the agent took
env_action: :class:`grid2op.Action.Action`
The modification that the environment will take.
prod_v_chronics: ``numpy.ndarray``
The next voltage setpoint present in the data (if any) or ``None`` if not.
Returns
-------
res: :class:`grid2op.Action.Action`
The new setpoint, in this case depending only on the prod_v_chronics.
"""
pass
def close(self):
"""If you require some "backend" to control the voltages, then you need to implement this
(and also some specific things for the copy) to have it working correctly
"""
pass