def _init_backend(self, init_grid_path, chronics_handler, backend, names_chronics_to_backend, actionClass, observationClass, rewardClass, legalActClass): self._env_dc = self.parameters.ENV_DC self.chronics_handler = chronics_handler self.backend = backend self._has_been_initialized() self._obsClass = observationClass if not issubclass(legalActClass, BaseRules): raise Grid2OpException( "Parameter \"legalActClass\" used to build the Environment should derived form the " "grid2op.BaseRules class, type provided is \"{}\"".format( type(legalActClass))) self._game_rules = RulesChecker(legalActClass=legalActClass) self._legalActClass = legalActClass self._helper_action_player = self._do_nothing self.backend.set_thermal_limit(self._thermal_limit_a) self._create_opponent() self.current_obs_init = self._obsClass(seed=None, obs_env=None, action_helper=None) self.current_obs = self.current_obs_init # backend has loaded everything self._line_status = np.ones(shape=self.n_line, dtype=dt_bool) self._hazard_duration = np.zeros(shape=self.n_line, dtype=dt_int) self._has_been_initialized()
def init_backend(self, init_grid_path, chronics_handler, backend, names_chronics_to_backend, actionClass, observationClass, rewardClass, legalActClass): """ backend should not be the backend of the environment!!! Parameters ---------- init_grid_path chronics_handler backend names_chronics_to_backend actionClass observationClass rewardClass legalActClass Returns ------- """ self.env_dc = self.parameters.FORECAST_DC self.chronics_handler = chronics_handler self.backend = backend self._has_been_initialized() self.obsClass = observationClass if not issubclass(legalActClass, BaseRules): raise Grid2OpException( "Parameter \"legalActClass\" used to build the Environment should derived form the " "grid2op.BaseRules class, type provided is \"{}\"".format( type(legalActClass))) self.game_rules = RulesChecker(legalActClass=legalActClass) self.legalActClass = legalActClass self.helper_action_player = self._do_nothing self.backend.set_thermal_limit(self._thermal_limit_a) self._create_opponent() self.gen_activeprod_t_init = np.zeros(self.n_gen, dtype=dt_float) self.gen_activeprod_t_redisp_init = np.zeros(self.n_gen, dtype=dt_float) self.times_before_line_status_actionable_init = np.zeros(self.n_line, dtype=dt_int) self.times_before_topology_actionable_init = np.zeros(self.n_sub, dtype=dt_int) self.time_next_maintenance_init = np.zeros(self.n_line, dtype=dt_int) self.duration_next_maintenance_init = np.zeros(self.n_line, dtype=dt_int) self.target_dispatch_init = np.zeros(self.n_gen, dtype=dt_float) self.actual_dispatch_init = np.zeros(self.n_gen, dtype=dt_float) self.last_bus_line_or_init = np.zeros(self.n_line, dtype=dt_int) self.last_bus_line_ex_init = np.zeros(self.n_line, dtype=dt_int) self.current_obs_init = self.obsClass(seed=None, obs_env=None, action_helper=None) self.current_obs = self.current_obs_init
def test_illegal_detected(self): act = self.env.helper_action_player({"set_line_status": [(1, -1)]}) self.env.game_rules = RulesChecker(legalActClass=DefaultRules) self.env.times_before_line_status_actionable[1] = 1 obs, reward, done, info = self.env.step(act) # the action is illegal and it has not been implemented on the powergrid assert not info['is_ambiguous'] assert info["is_illegal"] assert np.sum(obs.line_status) == 8
def _init_backend( self, chronics_handler, backend, names_chronics_to_backend, actionClass, observationClass, # base grid2op type rewardClass, legalActClass): self._env_dc = self.parameters.ENV_DC self.chronics_handler = chronics_handler self.backend = backend self._has_been_initialized( ) # really important to include this piece of code! and just here after the if not issubclass(legalActClass, BaseRules): raise Grid2OpException( "Parameter \"legalActClass\" used to build the Environment should derived form the " "grid2op.BaseRules class, type provided is \"{}\"".format( type(legalActClass))) self._game_rules = RulesChecker(legalActClass=legalActClass) self._legalActClass = legalActClass # self._action_space = self._do_nothing self.backend.set_thermal_limit(self._thermal_limit_a) # create the opponent self._create_opponent() # create the attention budget self._create_attention_budget() self._obsClass = observationClass.init_grid(type(self.backend)) self._obsClass._INIT_GRID_CLS = observationClass self.current_obs_init = self._obsClass(seed=None, obs_env=None, action_helper=None) self.current_obs = self.current_obs_init # backend has loaded everything self._hazard_duration = np.zeros(shape=self.n_line, dtype=dt_int)
def init_backend(self, init_grid_path, chronics_handler, backend, names_chronics_to_backend, actionClass, observationClass, rewardClass, legalActClass): """ backend should not be the backend of the environment!!! Parameters ---------- init_grid_path chronics_handler backend names_chronics_to_backend actionClass observationClass rewardClass legalActClass Returns ------- """ self.env_dc = self.parameters.FORECAST_DC self.chronics_handler = chronics_handler self.backend = backend self.init_grid(self.backend) self._has_been_initialized() self.obsClass = observationClass if not issubclass(legalActClass, BaseRules): raise Grid2OpException( "Parameter \"legalActClass\" used to build the Environment should derived form the " "grid2op.BaseRules class, type provided is \"{}\"".format( type(legalActClass))) self.game_rules = RulesChecker(legalActClass=legalActClass) self.legalActClass = legalActClass self.helper_action_player = self._do_nothing self.backend.set_thermal_limit(self._thermal_limit_a) self._create_opponent()
def setUp(self): """ The case file is a representation of the case14 as found in the ieee14 powergrid. :return: """ # from ADNBackend import ADNBackend # self.backend = ADNBackend() # self.path_matpower = "/home/donnotben/Documents/RL4Grid/RL4Grid/data" # self.case_file = "ieee14_ADN.xml" # self.backend.load_grid(self.path_matpower, self.case_file) self.tolvect = 1e-2 self.tol_one = 1e-5 self.game_rules = RulesChecker() # pdb.set_trace() self.rewardClass = L2RPNReward self.reward_helper = self.rewardClass() self.obsClass = CompleteObservation self.parameters = Parameters() # powergrid self.backend = PandaPowerBackend() self.path_matpower = PATH_DATA_TEST_PP self.case_file = "test_case14.json" # chronics self.path_chron = os.path.join(PATH_CHRONICS, "chronics_with_hazards") self.chronics_handler = ChronicsHandler( chronicsClass=GridStateFromFile, path=self.path_chron) self.tolvect = 1e-2 self.tol_one = 1e-5 self.id_chron_to_back_load = np.array( [0, 1, 10, 2, 3, 4, 5, 6, 7, 8, 9]) # force the verbose backend self.backend.detailed_infos_for_cascading_failures = True self.names_chronics_to_backend = { "loads": { "2_C-10.61": 'load_1_0', "3_C151.15": 'load_2_1', "14_C63.6": 'load_13_2', "4_C-9.47": 'load_3_3', "5_C201.84": 'load_4_4', "6_C-6.27": 'load_5_5', "9_C130.49": 'load_8_6', "10_C228.66": 'load_9_7', "11_C-138.89": 'load_10_8', "12_C-27.88": 'load_11_9', "13_C-13.33": 'load_12_10' }, "lines": { '1_2_1': '0_1_0', '1_5_2': '0_4_1', '9_10_16': '8_9_2', '9_14_17': '8_13_3', '10_11_18': '9_10_4', '12_13_19': '11_12_5', '13_14_20': '12_13_6', '2_3_3': '1_2_7', '2_4_4': '1_3_8', '2_5_5': '1_4_9', '3_4_6': '2_3_10', '4_5_7': '3_4_11', '6_11_11': '5_10_12', '6_12_12': '5_11_13', '6_13_13': '5_12_14', '4_7_8': '3_6_15', '4_9_9': '3_8_16', '5_6_10': '4_5_17', '7_8_14': '6_7_18', '7_9_15': '6_8_19' }, "prods": { "1_G137.1": 'gen_0_4', "3_G36.31": "gen_2_1", "6_G63.29": "gen_5_2", "2_G-56.47": "gen_1_0", "8_G40.43": "gen_7_3" }, } # _parameters for the environment self.env_params = Parameters() with warnings.catch_warnings(): warnings.filterwarnings("ignore") self.env = Environment( init_grid_path=os.path.join(self.path_matpower, self.case_file), backend=self.backend, chronics_handler=self.chronics_handler, parameters=self.env_params, names_chronics_to_backend=self.names_chronics_to_backend, rewardClass=self.rewardClass, name="test_obs_env1")
def init_backend(self, init_grid_path, chronics_handler, backend, names_chronics_to_backend, actionClass, observationClass, rewardClass, legalActClass): if not isinstance(rewardClass, type): raise Grid2OpException( "Parameter \"rewardClass\" used to build the Environment should be a type (a class) " "and not an object (an instance of a class). " "It is currently \"{}\"".format(type(rewardClass))) if not issubclass(rewardClass, BaseReward): raise Grid2OpException( "Parameter \"rewardClass\" used to build the Environment should derived form the grid2op.BaseReward class, " "type provided is \"{}\"".format(type(rewardClass))) self.rewardClass = rewardClass self.actionClass = actionClass self.observationClass = observationClass # backend self.init_grid_path = os.path.abspath(init_grid_path) if not isinstance(backend, Backend): raise Grid2OpException( "Parameter \"backend\" used to build the Environment should derived form the grid2op.Backend class, " "type provided is \"{}\"".format(type(backend))) self.backend = backend self.backend.load_grid( self.init_grid_path) # the real powergrid of the environment self.backend.load_redispacthing_data( os.path.split(self.init_grid_path)[0]) self.backend.load_grid_layout(os.path.split(self.init_grid_path)[0]) self.backend.assert_grid_correct() self.init_grid(backend) self._has_been_initialized( ) # really important to include this piece of code! if self._thermal_limit_a is None: self._thermal_limit_a = self.backend.thermal_limit_a else: self.backend.set_thermal_limit(self._thermal_limit_a) *_, tmp = self.backend.generators_info() # rules of the game if not isinstance(legalActClass, type): raise Grid2OpException( "Parameter \"legalActClass\" used to build the Environment should be a type " "(a class) and not an object (an instance of a class). " "It is currently \"{}\"".format(type(legalActClass))) if not issubclass(legalActClass, BaseRules): raise Grid2OpException( "Parameter \"legalActClass\" used to build the Environment should derived form the " "grid2op.BaseRules class, type provided is \"{}\"".format( type(legalActClass))) self.game_rules = RulesChecker(legalActClass=legalActClass) self.legalActClass = legalActClass # action helper if not isinstance(actionClass, type): raise Grid2OpException( "Parameter \"actionClass\" used to build the Environment should be a type (a class) " "and not an object (an instance of a class). " "It is currently \"{}\"".format(type(legalActClass))) if not issubclass(actionClass, BaseAction): raise Grid2OpException( "Parameter \"actionClass\" used to build the Environment should derived form the " "grid2op.BaseAction class, type provided is \"{}\"".format( type(actionClass))) if not isinstance(observationClass, type): raise Grid2OpException( "Parameter \"actionClass\" used to build the Environment should be a type (a class) " "and not an object (an instance of a class). " "It is currently \"{}\"".format(type(legalActClass))) if not issubclass(observationClass, BaseObservation): raise Grid2OpException( "Parameter \"observationClass\" used to build the Environment should derived form the " "grid2op.BaseObservation class, type provided is \"{}\"". format(type(observationClass))) # action affecting the grid that will be made by the agent self.helper_action_player = ActionSpace( gridobj=self.backend, actionClass=actionClass, legal_action=self.game_rules.legal_action) # action that affect the grid made by the environment. self.helper_action_env = ActionSpace( gridobj=self.backend, actionClass=CompleteAction, legal_action=self.game_rules.legal_action) self.helper_observation = ObservationSpace( gridobj=self.backend, observationClass=observationClass, rewardClass=rewardClass, env=self) # handles input data if not isinstance(chronics_handler, ChronicsHandler): raise Grid2OpException( "Parameter \"chronics_handler\" used to build the Environment should derived form the " "grid2op.ChronicsHandler class, type provided is \"{}\"". format(type(chronics_handler))) self.chronics_handler = chronics_handler self.chronics_handler.initialize( self.name_load, self.name_gen, self.name_line, self.name_sub, names_chronics_to_backend=names_chronics_to_backend) self.names_chronics_to_backend = names_chronics_to_backend # test to make sure the backend is consistent with the chronics generator self.chronics_handler.check_validity(self.backend) # reward function self.reward_helper = RewardHelper(self.rewardClass) self.reward_helper.initialize(self) for k, v in self.other_rewards.items(): v.initialize(self) # controler for voltage if not issubclass(self.voltagecontrolerClass, BaseVoltageController): raise Grid2OpException( "Parameter \"voltagecontrolClass\" should derive from \"ControlVoltageFromFile\"." ) self.voltage_controler = self.voltagecontrolerClass( gridobj=self.backend, controler_backend=self.backend) # create the opponent # At least the 3 following attributes should be set before calling _create_opponent # self.opponent_action_class # self.opponent_class # self.opponent_init_budget self._create_opponent() # performs one step to load the environment properly (first action need to be taken at first time step after # first injections given) self._reset_maintenance() do_nothing = self.helper_action_env({}) *_, fail_to_start, info = self.step(do_nothing) if fail_to_start: raise Grid2OpException( "Impossible to initialize the powergrid, the powerflow diverge at iteration 0. " "Available information are: {}".format(info)) # test the backend returns object of the proper size self.backend.assert_grid_correct_after_powerflow() # for gym compatibility self.action_space = self.helper_action_player # this should be an action !!! self.observation_space = self.helper_observation # this return an observation. self.reward_range = self.reward_helper.range() self.viewer = None self.metadata = {'render.modes': ["human", "rgb_array"]} self.spec = None self.current_reward = self.reward_range[0] self.done = False # reset everything to be consistent self._reset_vectors_and_timings()
def setUp(self): """ The case file is a representation of the case14 as found in the ieee14 powergrid. :return: """ self.tolvect = 1e-2 self.tol_one = 1e-5 self.game_rules = RulesChecker() self.gridobj = GridObjects() self.gridobj.init_grid_vect( name_prod=["gen_{}".format(i) for i in range(5)], name_load=["load_{}".format(i) for i in range(11)], name_line=["line_{}".format(i) for i in range(20)], name_sub=["sub_{}".format(i) for i in range(14)], sub_info=np.array([3, 6, 4, 6, 5, 6, 3, 2, 5, 3, 3, 3, 4, 3], dtype=np.int), load_to_subid=np.array([1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13]), gen_to_subid=np.array([0, 1, 2, 5, 7]), line_or_to_subid=np.array( [0, 0, 1, 1, 1, 2, 3, 3, 3, 4, 5, 5, 5, 6, 6, 8, 8, 9, 11, 12]), line_ex_to_subid=np.array([ 1, 4, 2, 3, 4, 3, 4, 6, 8, 5, 10, 11, 12, 7, 8, 9, 13, 10, 12, 13 ]), load_to_sub_pos=np.array([4, 2, 5, 4, 4, 4, 1, 1, 1, 2, 1]), gen_to_sub_pos=np.array([2, 5, 3, 5, 1]), line_or_to_sub_pos=np.array( [0, 1, 1, 2, 3, 1, 2, 3, 4, 3, 1, 2, 3, 1, 2, 2, 3, 0, 0, 1]), line_ex_to_sub_pos=np.array( [0, 0, 0, 0, 1, 1, 2, 0, 0, 0, 2, 2, 3, 0, 1, 2, 2, 0, 0, 0]), load_pos_topo_vect=np.array( [7, 11, 18, 23, 28, 39, 41, 44, 47, 51, 54]), gen_pos_topo_vect=np.array([2, 8, 12, 29, 34]), line_or_pos_topo_vect=np.array([ 0, 1, 4, 5, 6, 10, 15, 16, 17, 22, 25, 26, 27, 31, 32, 37, 38, 40, 46, 50 ]), line_ex_pos_topo_vect=np.array([ 3, 19, 9, 13, 20, 14, 21, 30, 35, 24, 45, 48, 52, 33, 36, 42, 55, 43, 49, 53 ])) # pdb.set_trace() self.res = { 'name_gen': ['gen_0', 'gen_1', 'gen_2', 'gen_3', 'gen_4'], 'name_load': [ 'load_0', 'load_1', 'load_2', 'load_3', 'load_4', 'load_5', 'load_6', 'load_7', 'load_8', 'load_9', 'load_10' ], 'name_line': [ 'line_0', 'line_1', 'line_2', 'line_3', 'line_4', 'line_5', 'line_6', 'line_7', 'line_8', 'line_9', 'line_10', 'line_11', 'line_12', 'line_13', 'line_14', 'line_15', 'line_16', 'line_17', 'line_18', 'line_19' ], 'name_sub': [ 'sub_0', 'sub_1', 'sub_2', 'sub_3', 'sub_4', 'sub_5', 'sub_6', 'sub_7', 'sub_8', 'sub_9', 'sub_10', 'sub_11', 'sub_12', 'sub_13' ], 'sub_info': [3, 6, 4, 6, 5, 6, 3, 2, 5, 3, 3, 3, 4, 3], 'load_to_subid': [1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13], 'gen_to_subid': [0, 1, 2, 5, 7], 'line_or_to_subid': [0, 0, 1, 1, 1, 2, 3, 3, 3, 4, 5, 5, 5, 6, 6, 8, 8, 9, 11, 12], 'line_ex_to_subid': [ 1, 4, 2, 3, 4, 3, 4, 6, 8, 5, 10, 11, 12, 7, 8, 9, 13, 10, 12, 13 ], 'load_to_sub_pos': [4, 2, 5, 4, 4, 4, 1, 1, 1, 2, 1], 'gen_to_sub_pos': [2, 5, 3, 5, 1], 'line_or_to_sub_pos': [0, 1, 1, 2, 3, 1, 2, 3, 4, 3, 1, 2, 3, 1, 2, 2, 3, 0, 0, 1], 'line_ex_to_sub_pos': [0, 0, 0, 0, 1, 1, 2, 0, 0, 0, 2, 2, 3, 0, 1, 2, 2, 0, 0, 0], 'load_pos_topo_vect': [7, 11, 18, 23, 28, 39, 41, 44, 47, 51, 54], 'gen_pos_topo_vect': [2, 8, 12, 29, 34], 'line_or_pos_topo_vect': [ 0, 1, 4, 5, 6, 10, 15, 16, 17, 22, 25, 26, 27, 31, 32, 37, 38, 40, 46, 50 ], 'line_ex_pos_topo_vect': [ 3, 19, 9, 13, 20, 14, 21, 30, 35, 24, 45, 48, 52, 33, 36, 42, 55, 43, 49, 53 ], 'gen_type': None, 'gen_pmin': None, 'gen_pmax': None, 'gen_redispatchable': None, 'gen_max_ramp_up': None, 'gen_max_ramp_down': None, 'gen_min_uptime': None, 'gen_min_downtime': None, 'gen_cost_per_MW': None, 'gen_startup_cost': None, 'gen_shutdown_cost': None, "grid_layout": None, "shunt_to_subid": None, "name_shunt": None } # self.size_act = 229 # self.helper_action = ActionSpace(self.gridobj, legal_action=self.game_rules.legal_action) self.helper_action = self._action_setup() save_to_dict(self.res, self.helper_action, "subtype", lambda x: re.sub("(<class ')|('>)", "", "{}".format(x))) # print(self.res["subtype"]) self.authorized_keys = self.helper_action().authorized_keys self.size_act = self.helper_action.size()
def _init_backend(self, init_grid_path, chronics_handler, backend, names_chronics_to_backend, actionClass, observationClass, rewardClass, legalActClass): """ INTERNAL .. warning:: /!\\\\ Internal, do not use unless you know what you are doing /!\\\\ Create a proper and valid environment. """ if not isinstance(rewardClass, type): raise Grid2OpException( "Parameter \"rewardClass\" used to build the Environment should be a type (a class) " "and not an object (an instance of a class). " "It is currently \"{}\"".format(type(rewardClass))) if not issubclass(rewardClass, BaseReward): raise Grid2OpException( "Parameter \"rewardClass\" used to build the Environment should derived form " "the grid2op.BaseReward class, type provided is \"{}\"".format( type(rewardClass))) self._rewardClass = rewardClass self._actionClass = actionClass self._observationClass = observationClass # backend self._init_grid_path = os.path.abspath(init_grid_path) if not isinstance(backend, Backend): raise Grid2OpException( "Parameter \"backend\" used to build the Environment should derived form the " "grid2op.Backend class, type provided is \"{}\"".format( type(backend))) self.backend = backend # all the above should be done in this exact order, otherwise some weird behaviour might occur # this is due to the class attribute self.backend.set_env_name(self.name) self.backend.load_grid( self._init_grid_path) # the real powergrid of the environment self.backend.load_redispacthing_data(self.get_path_env()) self.backend.load_storage_data(self.get_path_env()) self.backend.load_grid_layout(self.get_path_env()) self.backend.assert_grid_correct() self._has_been_initialized( ) # really important to include this piece of code! and just here after the # backend has loaded everything self._line_status = np.ones(shape=self.n_line, dtype=dt_bool) if self._thermal_limit_a is None: self._thermal_limit_a = self.backend.thermal_limit_a.astype( dt_float) else: self.backend.set_thermal_limit( self._thermal_limit_a.astype(dt_float)) *_, tmp = self.backend.generators_info() # rules of the game if not isinstance(legalActClass, type): raise Grid2OpException( "Parameter \"legalActClass\" used to build the Environment should be a type " "(a class) and not an object (an instance of a class). " "It is currently \"{}\"".format(type(legalActClass))) if not issubclass(legalActClass, BaseRules): raise Grid2OpException( "Parameter \"legalActClass\" used to build the Environment should derived form the " "grid2op.BaseRules class, type provided is \"{}\"".format( type(legalActClass))) self._game_rules = RulesChecker(legalActClass=legalActClass) self._legalActClass = legalActClass # action helper if not isinstance(actionClass, type): raise Grid2OpException( "Parameter \"actionClass\" used to build the Environment should be a type (a class) " "and not an object (an instance of a class). " "It is currently \"{}\"".format(type(legalActClass))) if not issubclass(actionClass, BaseAction): raise Grid2OpException( "Parameter \"actionClass\" used to build the Environment should derived form the " "grid2op.BaseAction class, type provided is \"{}\"".format( type(actionClass))) if not isinstance(observationClass, type): raise Grid2OpException( "Parameter \"actionClass\" used to build the Environment should be a type (a class) " "and not an object (an instance of a class). " "It is currently \"{}\"".format(type(legalActClass))) if not issubclass(observationClass, BaseObservation): raise Grid2OpException( "Parameter \"observationClass\" used to build the Environment should derived form the " "grid2op.BaseObservation class, type provided is \"{}\"". format(type(observationClass))) # action affecting the grid that will be made by the agent self._helper_action_class = ActionSpace.init_grid(gridobj=self.backend) self._helper_action_player = self._helper_action_class( gridobj=self.backend, actionClass=actionClass, legal_action=self._game_rules.legal_action) # action that affect the grid made by the environment. self._helper_action_env = self._helper_action_class( gridobj=self.backend, actionClass=CompleteAction, legal_action=self._game_rules.legal_action) self._helper_observation_class = ObservationSpace.init_grid( gridobj=self.backend) self._helper_observation = self._helper_observation_class( gridobj=self.backend, observationClass=observationClass, rewardClass=rewardClass, env=self) # handles input data if not isinstance(chronics_handler, ChronicsHandler): raise Grid2OpException( "Parameter \"chronics_handler\" used to build the Environment should derived form the " "grid2op.ChronicsHandler class, type provided is \"{}\"". format(type(chronics_handler))) self.chronics_handler = chronics_handler self.chronics_handler.initialize( self.name_load, self.name_gen, self.name_line, self.name_sub, names_chronics_to_backend=names_chronics_to_backend) self.names_chronics_to_backend = names_chronics_to_backend # test to make sure the backend is consistent with the chronics generator self.chronics_handler.check_validity(self.backend) self.delta_time_seconds = dt_float( self.chronics_handler.time_interval.seconds) self._reset_storage( ) # this should be called after the self.delta_time_seconds is set # reward function self._reward_helper = RewardHelper(self._rewardClass) self._reward_helper.initialize(self) for k, v in self.other_rewards.items(): v.initialize(self) # controller for voltage if not issubclass(self._voltagecontrolerClass, BaseVoltageController): raise Grid2OpException( "Parameter \"voltagecontrolClass\" should derive from \"ControlVoltageFromFile\"." ) self._voltage_controler = self._voltagecontrolerClass( gridobj=self.backend, controler_backend=self.backend) # create the opponent # At least the 3 following attributes should be set before calling _create_opponent self._create_opponent() # performs one step to load the environment properly (first action need to be taken at first time step after # first injections given) self._reset_maintenance() self._reset_redispatching() do_nothing = self._helper_action_env({}) *_, fail_to_start, info = self.step(do_nothing) if fail_to_start: raise Grid2OpException( "Impossible to initialize the powergrid, the powerflow diverge at iteration 0. " "Available information are: {}".format(info)) # test the backend returns object of the proper size self.backend.assert_grid_correct_after_powerflow() # for gym compatibility self.action_space = self._helper_action_player # this should be an action !!! self.observation_space = self._helper_observation # this return an observation. self.reward_range = self._reward_helper.range() self.viewer = None self.viewer_fig = None self.metadata = {'render.modes': []} self.spec = None self.current_reward = self.reward_range[0] self.done = False # reset everything to be consistent self._reset_vectors_and_timings()