From 4428ff40644242061689cec010b1d1cf2701ca87 Mon Sep 17 00:00:00 2001 From: Eva BOGUSLAWSKI Date: Tue, 5 Sep 2023 16:31:51 +0200 Subject: [PATCH 01/18] fix issue 446: problem with BoxGymObsSpace when normalizing --- grid2op/gym_compat/box_gym_obsspace.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/grid2op/gym_compat/box_gym_obsspace.py b/grid2op/gym_compat/box_gym_obsspace.py index edb979383..d0aecf761 100644 --- a/grid2op/gym_compat/box_gym_obsspace.py +++ b/grid2op/gym_compat/box_gym_obsspace.py @@ -618,10 +618,10 @@ def __init__( if subtract is None: subtract = {} - self._subtract = subtract + self._subtract = subtract.copy() if divide is None: divide = {} - self._divide = divide + self._divide = divide.copy() # handle the "functional" part self._template_obs = ob_sp._template_obj.copy() From ac503f169062437cd816cd1ff93ea5403efaa34f Mon Sep 17 00:00:00 2001 From: Eva BOGUSLAWSKI Date: Tue, 5 Sep 2023 18:43:02 +0200 Subject: [PATCH 02/18] add test for previous fix for issue 446 --- grid2op/tests/test_issue_446.py | 40 +++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 grid2op/tests/test_issue_446.py diff --git a/grid2op/tests/test_issue_446.py b/grid2op/tests/test_issue_446.py new file mode 100644 index 000000000..2a09853eb --- /dev/null +++ b/grid2op/tests/test_issue_446.py @@ -0,0 +1,40 @@ +# Copyright (c) 2023, 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. + + +import grid2op +from grid2op.gym_compat import BoxGymActSpace, BoxGymObsSpace +import numpy as np +import unittest + + +class Issue446Tester(unittest.TestCase): + def test_box_action_space(self): + # We considers only redispatching actions + env = grid2op.make("l2rpn_case14_sandbox", test=True) + + divide = {"hour_of_day": np.ones(1)} + + gym_observation_space_1 = BoxGymObsSpace(env.observation_space, + attr_to_keep=["curtailment_mw", "hour_of_day"], + divide = divide + ) + + gym_observation_space_2 = BoxGymObsSpace(env.observation_space.copy(), + attr_to_keep=["curtailment_mw", "hour_of_day"], + divide = divide + ) + + gym_observation_space_1.normalize_attr("curtailment_mw") + + assert "curtailment_mw" in gym_observation_space_1._divide + assert "curtailment_mw" not in gym_observation_space_2._divide + + +if __name__ == "__main__": + unittest.main() \ No newline at end of file From 2ea3c8ab365787fdca3381290942e7beec246540 Mon Sep 17 00:00:00 2001 From: Eva BOGUSLAWSKI Date: Tue, 5 Sep 2023 18:58:30 +0200 Subject: [PATCH 03/18] complete test for issue 446 --- grid2op/tests/test_issue_446.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/grid2op/tests/test_issue_446.py b/grid2op/tests/test_issue_446.py index 2a09853eb..d9aad58f7 100644 --- a/grid2op/tests/test_issue_446.py +++ b/grid2op/tests/test_issue_446.py @@ -19,21 +19,26 @@ def test_box_action_space(self): env = grid2op.make("l2rpn_case14_sandbox", test=True) divide = {"hour_of_day": np.ones(1)} + subtract = {"hour_of_day": np.zeros(1)} gym_observation_space_1 = BoxGymObsSpace(env.observation_space, attr_to_keep=["curtailment_mw", "hour_of_day"], - divide = divide + divide = divide, + subtract = subtract ) gym_observation_space_2 = BoxGymObsSpace(env.observation_space.copy(), attr_to_keep=["curtailment_mw", "hour_of_day"], - divide = divide + divide = divide, + subtract = subtract ) gym_observation_space_1.normalize_attr("curtailment_mw") assert "curtailment_mw" in gym_observation_space_1._divide assert "curtailment_mw" not in gym_observation_space_2._divide + assert "curtailment_mw" in gym_observation_space_1._subtract + assert "curtailment_mw" not in gym_observation_space_2._subtract if __name__ == "__main__": From a91b44e2c18b0281d33cf5b2d605ab82033efe49 Mon Sep 17 00:00:00 2001 From: DONNOT Benjamin Date: Tue, 12 Sep 2023 18:19:42 +0200 Subject: [PATCH 04/18] fixing issue rte-france#518 --- .gitignore | 5 + _profiling/profiler_assessment.py | 2 +- _profiling/utils_benchmark.py | 4 +- grid2op/Chronics/fromOneEpisodeData.py | 2 +- grid2op/Environment/_obsEnv.py | 4 +- grid2op/Observation/observationSpace.py | 4 +- grid2op/Space/GridObjects.py | 2 +- .../chronics/2019-01-12/load_p.csv.bz2 | Bin 0 -> 2729 bytes .../2019-01-12/load_p_forecasted.csv.bz2 | Bin 0 -> 2396 bytes .../chronics/2019-01-12/load_q.csv.bz2 | Bin 0 -> 2412 bytes .../2019-01-12/load_q_forecasted.csv.bz2 | Bin 0 -> 1987 bytes .../chronics/2019-01-12/prod_p.csv.bz2 | Bin 0 -> 1912 bytes .../2019-01-12/prod_p_forecasted.csv.bz2 | Bin 0 -> 1787 bytes .../chronics/2019-01-12/prod_v.csv.bz2 | Bin 0 -> 116 bytes .../2019-01-12/prod_v_forecasted.csv.bz2 | Bin 0 -> 116 bytes .../chronics/2019-01-12/start_datetime.info | 1 + .../chronics/2019-01-12/time_interval.info | 1 + .../chronics/2019-01-13/load_p.csv.bz2 | Bin 0 -> 2645 bytes .../2019-01-13/load_p_forecasted.csv.bz2 | Bin 0 -> 2221 bytes .../chronics/2019-01-13/load_q.csv.bz2 | Bin 0 -> 2311 bytes .../2019-01-13/load_q_forecasted.csv.bz2 | Bin 0 -> 1884 bytes .../chronics/2019-01-13/prod_p.csv.bz2 | Bin 0 -> 1867 bytes .../2019-01-13/prod_p_forecasted.csv.bz2 | Bin 0 -> 1710 bytes .../chronics/2019-01-13/prod_v.csv.bz2 | Bin 0 -> 116 bytes .../2019-01-13/prod_v_forecasted.csv.bz2 | Bin 0 -> 116 bytes .../chronics/2019-01-13/start_datetime.info | 1 + .../chronics/2019-01-13/time_interval.info | 1 + .../config.py | 42 + .../difficulty_levels.json | 58 + .../grid.json | 1766 +++++++++++++++++ .../grid_forecast.json | 1766 +++++++++++++++++ .../grid_layout.json | 58 + .../prods_charac.csv | 7 + .../storage_units_charac.csv | 3 + grid2op/tests/test_issue_sim2real_storage.py | 37 +- 35 files changed, 3752 insertions(+), 12 deletions(-) create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/load_p.csv.bz2 create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/load_p_forecasted.csv.bz2 create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/load_q.csv.bz2 create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/load_q_forecasted.csv.bz2 create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/prod_p.csv.bz2 create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/prod_p_forecasted.csv.bz2 create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/prod_v.csv.bz2 create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/prod_v_forecasted.csv.bz2 create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/start_datetime.info create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/time_interval.info create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/load_p.csv.bz2 create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/load_p_forecasted.csv.bz2 create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/load_q.csv.bz2 create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/load_q_forecasted.csv.bz2 create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/prod_p.csv.bz2 create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/prod_p_forecasted.csv.bz2 create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/prod_v.csv.bz2 create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/prod_v_forecasted.csv.bz2 create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/start_datetime.info create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/time_interval.info create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/config.py create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/difficulty_levels.json create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/grid.json create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/grid_forecast.json create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/grid_layout.json create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/prods_charac.csv create mode 100644 grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/storage_units_charac.csv diff --git a/.gitignore b/.gitignore index 2dc7408af..c97dd3095 100644 --- a/.gitignore +++ b/.gitignore @@ -386,6 +386,11 @@ test_malte.py example_gym_act.py test_to_fix.txt doc_raise_alert.py +_profiling/profile.html +_profiling/profile.json +actspace_converter.py +grid2op/data_test/input_data_local/ +test_sim2real_battery.py # profiling files **.prof diff --git a/_profiling/profiler_assessment.py b/_profiling/profiler_assessment.py index 95aef78bb..3624dcd1d 100644 --- a/_profiling/profiler_assessment.py +++ b/_profiling/profiler_assessment.py @@ -28,7 +28,7 @@ from utils_benchmark import run_env, str2bool, ProfileAgent try: - from lightsim2grid.LightSimBackend import LightSimBackend + from lightsim2grid import LightSimBackend light_sim_avail = True except ImportError: light_sim_avail = False diff --git a/_profiling/utils_benchmark.py b/_profiling/utils_benchmark.py index e8a732b83..af207d7d2 100644 --- a/_profiling/utils_benchmark.py +++ b/_profiling/utils_benchmark.py @@ -152,9 +152,9 @@ def __init__(self, self.action_space.all_actions = all_actions # add the action "reset everything to bus 1" - self.action_space.all_actions.append(action_space({"set_bus": np.ones(action_space.dim_topo, dtype=np.int), + self.action_space.all_actions.append(action_space({"set_bus": np.ones(action_space.dim_topo, dtype=int), "set_line_status": np.ones(action_space.n_line, - dtype=np.int)})) + dtype=int)})) def print_res(env_klu, env_pp, diff --git a/grid2op/Chronics/fromOneEpisodeData.py b/grid2op/Chronics/fromOneEpisodeData.py index 39ba20426..a21324337 100644 --- a/grid2op/Chronics/fromOneEpisodeData.py +++ b/grid2op/Chronics/fromOneEpisodeData.py @@ -64,7 +64,7 @@ class FromOneEpisodeData(GridValue): parameters (see example below) .. seealso:: - :class:`grid2op.Chronics.FromMultiEpisodeData`if you want to use multiple episode data + :class:`grid2op.Chronics.FromMultiEpisodeData` if you want to use multiple episode data Examples --------- diff --git a/grid2op/Environment/_obsEnv.py b/grid2op/Environment/_obsEnv.py index 8db0060d4..421ba2490 100644 --- a/grid2op/Environment/_obsEnv.py +++ b/grid2op/Environment/_obsEnv.py @@ -192,8 +192,8 @@ def _init_backend( from grid2op.Observation import ObservationSpace from grid2op.Reward import FlatReward - ob_sp_cls = ObservationSpace.init_grid(backend) - self._observation_space = ob_sp_cls(backend, + ob_sp_cls = ObservationSpace.init_grid(type(backend)) + self._observation_space = ob_sp_cls(type(backend), env=self, with_forecast=False, rewardClass=FlatReward, diff --git a/grid2op/Observation/observationSpace.py b/grid2op/Observation/observationSpace.py index afb2c919c..9e64ca48b 100644 --- a/grid2op/Observation/observationSpace.py +++ b/grid2op/Observation/observationSpace.py @@ -121,7 +121,7 @@ def __init__( self._ObsEnv_class._INIT_GRID_CLS = _ObsEnv # otherwise it's lost setattr(sys.modules[_ObsEnv.__module__], self._ObsEnv_class.__name__, self._ObsEnv_class) if _with_obs_env: - self._create_obs_env(env) + self._create_obs_env(env, observationClass) self.reward_helper.initialize(self.obs_env) for k, v in self.obs_env.other_rewards.items(): v.reset(self.obs_env) @@ -174,7 +174,7 @@ def set_real_env_kwargs(self, env): if "observation_bk_kwargs" in self._real_env_kwargs: del self._real_env_kwargs["observation_bk_kwargs"] - def _create_obs_env(self, env): + def _create_obs_env(self, env, observationClass): other_rewards = {k: v.rewardClass for k, v in env.other_rewards.items()} self.obs_env = self._ObsEnv_class( init_env_path=None, # don't leak the path of the real grid to the observation space diff --git a/grid2op/Space/GridObjects.py b/grid2op/Space/GridObjects.py index e885328da..a47b2a9aa 100644 --- a/grid2op/Space/GridObjects.py +++ b/grid2op/Space/GridObjects.py @@ -2709,7 +2709,7 @@ def init_grid(cls, gridobj, force=False, extra_name=None, force_module=None): # with shunt and without shunt, then # there might be issues name_res += "_noshunt" - + if name_res in globals(): if not force: # no need to recreate the class, it already exists diff --git a/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/load_p.csv.bz2 b/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/load_p.csv.bz2 new file mode 100644 index 0000000000000000000000000000000000000000..cb68d027506b1bad8e60a550c63e8e8e417ad1ea GIT binary patch literal 2729 zcmV;a3Rd+(T4*^jL0KkKS@U|>2LK$%TL1tM00DpK005)};1Lk60*wJcXaySh`asER zXo@`bR26v4K$zBGs#R3*)ba*ZQxgHIeh5mbiGfWrF)=X&nn+Bln3x4BPbf-g&;(Md zf9I-HnE+hRfdnC`jy!t2&rFN)3q~W<@#`}eR9;BJ+~>k@$cn{WXXVQ#hmigUfzD^% z&w2*EoD<--b)BxKRvXtNuJ)06*3yDw2AJ7o731J-36(wEr`7i23sjlIG;}QuhWd-E z>SwZq$Ou{~81vhB>`Ok=3^U1~not+sz~|ox02}ZXK?D{kBASz`$8EJ48%VadYuT}g zFzh%Gtb6Sm=iFZN?&|M-e&P4KsQ}gIp1#d*fiVGO8RN6wK!rVuAy*iAq!$F-_CFL_ve}4oDV8bk2R4`kU78 zJoWC#KV``Y#sNF_o-47o&aU{cxH5{qAXB96&ME zOea{14yyxB<4Xo}7^~Mia{?(DDK>MKpqJHjGv=1Zb5vS$iiS!=&ja$dg8ZD9v|k zcfX$S_m6pBq4rk%yZIlAQ4#N%SbMI!guFG(TcIzVhDzWLrS|~q(-9N?gKs{)qrwpU%UeK*d=JI+1pS@h^=_if`LH8ta5oDThYS% zx2usci-www&}q`d(OFX>%9ZMeBpL$==!u_6(lL=aODhU2<0BY=rzD(LM^1!3Vo8C7 zoE+1>b6fU(dhmPW!3VxodS}PohqZAk3!Fjw*o6$;({-tc(d?<|4Zvv_c^NVv5ZWDO z3Rqhu5a7X#${dm^=$jX(VL2h71NeP@`bajvqgO5#v%`Y_eS`U#QpDzp7T;JFLYo?9skoCO!v9@2aN3*l+E$1DZS2CFJv(MUGsIhuil14+x zNj!_GJhCDj5fKpvZiyGr+)!dCLU59k*uJ}N9{9_KK!(0)W8f&wV4mKP7(@sXc@e(} z1^{v9FQO*ZE8^pAv&pcOutg*+4vdH_Ml(?CScs16WNSr@XsB$SzJ~~d1dl>|vQHX< zXWSdDao;`GD2W%m0P2c>!0-lHgtkgbC+^&@QOr27yt%Ym+MO#s6OuoPAh2P^eti94 zNI^-=Vv-aRabUm^A4ir5LSkSgBnY`ZFoc(%2fQbMe0#@&7zerM#1c1--LBo<$|v8w zD&EoJY5>uZ5uNq19HklM>8iVi;yD27D$K3#!K|-K{GtZUb6rHMEuYek!cZ*M8755>3ri_&mfMh=fgm4kqyuwmiin_$ zXU7aM$Y4y&vW0CZcHvz^zUOvEWs!qA%%&YIVp!`r!z#0^aWPC}$jOohW<*gk5NfD2 z35H}u(N~2~BLP0hkXAXWnr`N1IUr=PvJ#kJh@p@SGZO-2xSV7&ra6?cnCBejkux#Q zRw`!hVXMF*79byC879Ls1knR=lPJ%<(^A~Cmkd>wSjt^mZ&S%HR&(u_i7wUeyUg{HiYX<%K|E>;NkXR% z=#X(dizQaB(LC?ZdBZA1LJ!>%&Qs<}oyU1T`kX+)r!uhD6Q@}u&~r|}=EcM@i-!}x zaaWseAC1B6o7IUI!`tn>v61t<+b{qB- zGt*rmHVgRBm}H1ZNy`L!c}WVyjpb!goGWzimZFw2@Ei(GH9gA6KF&7p)Sb6X);RX% zeHHgf-uutxvgRf;FS&8V3DTbo9hsu^feg|Qi$!>orl_f9%Z@qGAG2a~~^t{bG+i+Q&%X#OxS5@ONcDiLn^6OZ-(=Roe70mYT=*Lv@F^7~lJ0|)L z<3($$b_F5_RDs4a9L%o4(NT8qaks>7jnKWh8-CU{GaW&LIyh!hj<9yk;fm5p3T6(f z5$mnavh!gir@YN`_M293vN1cC9&)K7v&UX;k*{Y=7uYO16~PyKOrA%#Cxf*2OFZe! z=%2cB8m!6HgPdI*7{PS}b4IRqcX+HSyR4fLxWrmAa7dz!Y(ax7dzm(? z#DaW557s!gUBS9rAymD(9D$ie$m;2??1t^&li^NYO@_> z`mOGEaBh0~y8Oej$(%2?bSu>EAA1P*ZC@9Zb}GXvhz@w`jWFJB_%&unG4*!ai(L<(ct5vIN zwi9frm~wMFo=-fgxYv87@%g_gb~m1cyD&TC755({o;t+KbR5wtQs&nlVu)vTz-Jn7 zyLvr*G-pmX+bXqEmg&5woX&O5_~G^+v~aRlk|fIIr8*gQ=d)$VB`32LX7fj5ao&xY zxog`!VaJyAnqfWOK3D}OPkL23aouf>@-j&4aqfu)_1xI~hIMA%C*HcZa#O1_jT~1^ zsCSlUxdIhnFvErqc?I#Squ+-O-3kip0Sijwah((d;e18}jrS@#_8D(x4w8$}M&Dla jlI!dYDB;4(Zkhe}hv&RL!~4blr~F;X6yZWc&Ff$s$!ao$ literal 0 HcmV?d00001 diff --git a/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/load_p_forecasted.csv.bz2 b/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/load_p_forecasted.csv.bz2 new file mode 100644 index 0000000000000000000000000000000000000000..19c21de8bee86689649d464db037c90b59dc0b44 GIT binary patch literal 2396 zcmV-i38VHxT4*^jL0KkKSx(&28UP&1TL1tM00DpK005)};13;{_iI!VyJu|aZL@8f zpJ5~dYDZbNuY0}EGYgwQ>X|Oy8lHiQs$yUylVpumF)%5nMkXd8lS&$yRWUFTC#s4~ z0MH^q2}*51-r33|ZXZ=Ta(XBHzlwf3zVYSph{}sDnE3Uha(RwFU=xE2>k?&4bgA7iYgPpa`Y{U=#2`Wta1R?5 zM1Yo!T5|N@AjJ5X09c(gSKiCa%kO(UkFrt;r0-z^fQ0f01_bO`4Z?4zz(|537M#~`K_d^KWGNoUG5g);uetZ%Ie7EC?ejX`$+LF@ zCyEGt^Xh<{G*CIfx;t7-h}m1&gwO?&b%-Ak^dREQHDd-02-!tLd>mMvP~zRGM~pjt z%x-g#na+Z)O-{skt2~6u4Ba_C>U%K7<3Q;Rq~TOhQa2jYu96 zJOZ_83ll55uw0#;+wRKeyk&dWT@P!Y9x}n}6TPVRVZCs)R&rFM#-s9`28NgD#6I)z zL4y&IVupl>YJ?`3A0ANnTWni-&97g6>BZ6-hzEl30l#^9djdf~K`?^IFrO@_`!?v! z4j7s@CWTsLEvU=s6M#m*ihU$4Iti$Gk!gx?gkd#Cc=EgpiNG)k14m5uT+?p5ho`1y z>$YHnHt8B)Oh>6|)3jB4$gtKogeY;5l{|&pO?JcTy&UZX@m&RwkxmOZFvX1DQT3QpV7|#4#~L2E%bo0mJY$ z!NFQ-ia|tzC`2$A0~o?UhzXo{8oCH;hCI>eDu?fBM1UuI)4fDMD4_`wfRsIiA|e2T zSTQsv+G#LD2AdGT9!7-F4PAi?L;29SvYYB+6)#N1;_o#cZ%FEkIpBK;Z;v zT{ShZDJh|Cw#W{7!#?DhM~Iaf?}Km1nF<^J4I9Ao(PrvZ2qAW428IU zX#TDlW*D?4M*nl^kbx&C%xDbSbH?0+zza_Sv*$s~iql+yuwr;H$6=UB!Rv63A)GV} zAVO7fI_ep?!imd>(P_T*RwJj8M@-x>(w2g*odNOF8qU_Ne8Nvf7NjDX*WMEYBRYxI9!@sg^zDpmlH5YcPc2 zbX*l7czE9ZZxoW(2gULj^X}#|w8C(rV`fo-S){OaQFaC{Ly1@qc=8Ht%$9(^CqeCb zYqT`)nCw^CvCi@g7w>o=Mo+Pf9}tp|PTBizK6O0sM1+^=*(Qaw(9+s@*`}tK^>S3E z;7AI<(L8D%r4MMQ64|Ro;`??i^`T@-rRm`niX41cmv$?w1qLPEirRCISh}ZtXij44 z_ZHT63j`aNV)CwOp$*%yOSNGFM zP*(Q?VrrYcEi_aTQ&a12O7z#n=(01c$|uKS9-e%i?C;rzVUys%Reing2d|J^x^h^D z4uQn^;lXP=nwH$A9dON>k2OLibD~5ouQV@n2D8-{Bx)meMpMY4MpCWk(Ts>Y#T7xp zZJxZm*{RyD9N#6nEIXJI3bwU%!>+OA%+neU{+v}e9-Lg)oii_zOf=tDGCBG26 z6Hvg#wB(Kj!w;^52PM=p5W&2TIOS1w0u)#kRFejak>l4xspqTN)E(}enXANxCP8Ea zoV)o%L*9vzw^~HeG?225k!0y1@y`K-k6;dIspt|Bk|gtxI9mvH+sCO)gDm?As5E!F zy;KK#+(C%Qi_Ei+lQbZ74T=^*te4X22^@{{E0i$H^qIFCoi3}EsgxT^bw1%s*S*7W z?oRF(!!t1S+Sjy2OS(zu-ObnBk_{CD%*o_h0 zmTsC;$wy7!8ndP3GX0|AxrVy0!o{9sU<6QZU5jHzWN|!aazi)Vei^g2E3djq z&hqyWoVo3~DC&LE;ZW?S+AdmD+CN$CeXVNy<5y<%Rqo2Dd&ym_)1gLDJ(TL!8@bs= z`!?0#Z@;XlP~NIG<4}@w{L%x`cwKJSbxfY O#oUoj6eJV3G=_jk@?`M< literal 0 HcmV?d00001 diff --git a/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/load_q.csv.bz2 b/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/load_q.csv.bz2 new file mode 100644 index 0000000000000000000000000000000000000000..35d398131afc5122e48cffd2ceb6fdc0f2b119d3 GIT binary patch literal 2412 zcmV-y36u6hT4*^jL0KkKS+_42{s0?8TL1tM00DpK005)};15MEK9*hbU6o?613Jd57|~nwK1GIs3n=Y|NWM4NGQ;L*Wm5^KjjcBf_4m8A zB5p+`KK13}MKzHIA=NTju_eKR`?2XGlPcBv+XkKDt~|uu1Ujc`vBQHWVH9UjgBEd4 zRcSr8^k_^axiz5Gf?*1PU9%hFBjdAxTTkb`pE|f1IDslSr&E* zsDK07sv?J}0AhWkGjev3OU9WUQmAaRp}-qk2tov3!%%wImfl=&=g)9%A(N$ADt zFhHyca#%IQ+ z4+nk5k8QksRMfN9&TsYN+`<}uiU?Ue!4+ZQ zVHQCU4yqcGY@bL?*g=6aCym}-8m!344^`KI=Bz?|z+sF;U1;$@AUW*thRYbwbVhX& zU@}e+83PH_wWPMPKBkl?Lc{B<-JcLPSV)kKeh3+@_2K3BFL%m(4<@*00Uh1m6NkQ{ zUmO;CZTEb{Ms^l&ThIoNK%|n4U>=M{3W&!S?#z~A#bCO<{YS34hO0NfRFK!Ejhg27 zOg!;~z~0=K?nmjyoujnzkBt=MFI4qC*rNDcU{|1oI8>HcdWmAoJ>spYx92nWmHwyS z)itK8O=@N)>q|}AX}e6q+h)z%ZVEr2YLBPSn%3;uyIU~L+ih*S{y5`E(@u3$rWalL zeJHxTU%L^SiQ4mjW%tjwPBYEJtRJM#q;j1 znzm`9OfcQHz8vY!Q(9`fuC6Ed?=Mr;TUs;`@I&*nWqy6?d`8WyReo{QFXH> zp7H8=8IpSL9IRw@*G^1j9n-6ojH>Q*;LJ(ayn6Iz74Vh#${SC|)$(+X<;B%q`Q_mB zr>DGLFH*esuNQ>!hbL&(y6WdH z;_kbNLX-_i5Qfjr{!h!_ZN}76qL28>S|=gK!3zZs(m%Hl{Ncfx8{F<$u4?9mDA5=( zjgD(soux9%Q&o^;DY))HS?BHZs|wY0xG*wtmMn%H$4sF;4W&-p@IhQYTe}Y&o82$5 z+DKej4iVVso~O|JN(CPu8-R>PRPBAO%tH}=M)@qv`{eq;QhYyi*e;J9`@H*g6&ZJa zb*iwrb)up*l{W_L^d$8-SX|s2$wU!&;b5o&31mA!jai+;t+GKcbUWGZ5Fsg0UMQ-6^f+x+nwI<&2d-TDMP}|!I_TpSm<#?H+MW_D14sAhYy zva^Fu?sT)hkX`RR_5|#l+wLX>zPDGv!<*fPa4;r1=X5mgS`%`mN80gO6-!O@(`&fk zV#gXUrA#jB`PVvTbBUQ1Tk9lAT;-OP``AeYc%=leD`AYxixv%QC{abKD5$E<-gkS@ z+f|HFK@~O|?&o`&tgcnAcmhEnlVVZY1UB^6zdY=8h3@WMZFXI69d%cnnlB)Y77?Y&mA$<7_7W-G&DiRrx1(LLew1jeTcQ)sI_;TTI@QhH!E1|L zNZV5L8!+o?@zynaN3HEH%Z0*5jn7Sc5rC0vyECZE-AfZUdw}#HoDPXyw@!b8JCsZT;W;HEw2NMw zLSud1lU{kNjb~%0sPnxGbnZ4YJz~f%l`1hNm}A=A8`(=};AlkRS0?KnIMKveR4y*@ z_1b55Cw4b4-O}fu78X9|lm?EY~?(%bgE@Awb{}(A-)gXAwDLiCQ{PY7W@ejiR0(S z9Az(FquvAE51!|=%Ef!EJZ*G*F`ifNlM=J-tGm6Q3j5zKwPEe=5<-E(5h3@7A)UL| zVAH_i4Dh2xBv+f8J_Oz#H{)GmX7s%j>iz9(7IhfVG_j^wBsSApqX?QLd9i8Y63p=8 zZ_G(}!4&)%zY};7Q2TVn?K2HXr5{zdK$twqOBOBfbmE?gzRZCn5;hY=pCpDe+;Y^7 zc4;Y$9W#&`$gCjXf<#WP%nLHE!$bs#NQHHQK2+W-I%00DpK005)};0*nWzCP~iZ8f^>vykOb z1c7&2)p&ETbe8ST?X;Z@PY^X#F)$J%MK-FYCIvLe#KgoB5gKZeXkb#K)ez;V? zu18M~Q!Az8P?u+G)7N8t2_cwPZ?I5pcDI>F5z2op&ezoDTBfGxHguhq3jn6mowVo( zJQq-pxDye{1WxO~g1Yd>^-RUS1|U4SV#3ZR!fMrvL(9Hu#n8b#MGZ#+DnvU1Fkujk zhQdT5k3It-s(C}?4DWQmbluAi9pycWp-k}L@5OcKe7}Mz56=^aSjSr#2V6SjTppJw z3HC1w_15lg9iwLEY3klhq=FZU({VMNjim_9Z5UyA&Yc?pzMUBu2x)W}Kp;W^ zA*C3vka(mRnRhv#zJuiMl~D5wLq;5@L`>q?KAj;HdY^~SjY@`{iw@HfwgQ?oAVee( zffq`w2L(EWLL`2(*Y7m_(!pLtJ6Yh2(q3Jm@gNHz|rFjBP7IXuvQF zNNocKC#i`h1O!1a8clSM>2o7~)32R#GXvC&Bu?EkOiyW?FC)q+>w5HLl8hIqV245S zsn>vf07R)FplYc42rwsk)-l> z^(Tz3Na5YzoYr1?ZDdrc?UwA3>Bq24)#ZZl_(c8We0T;Ykt`UAK=cSk5-f+`ISvj( z7oVhfyH&)vcfU|c=_DlE$jPdlZi~7sZpLcfv76xO=ny#uK7R*>cm^I8pwJ&kHiZ}j zPe`zWu|fdie57Yx9C0yj9=&ACdGwY>dJ`Pg(avdBI*y!p7S~Y0O6(B@} z2od5nDpBpzrlLGmSFO@|dS%BKdQgEFM^VgiFhZpYrE1g)+U$*{4Fq{aJ>2YGSv-~Q zG-x`VF2%CNly>cQr#P0@8CjZY=OXRZ(B;TGb#ys$55cBca^jCttK*70Pj7EiL75pE zhGmOVWvfOZjIhvSEgFnvjYeA3urac-jb>sel_l$ic8_mP!=&Ija!xpoPE(Fbtc7{P z6dYiYfH8`&(W20)Q7KY_(xp{tTBy*WK^O#61yScB?0Gzn)Z}nob#_j^=2=!)%M`{j zs+!iBMzy0*)?t-dYgSj4RXuW(vUzyBE7h23HJWH_!z)>)rffB{Ctd1x?`yYRFC{7K z@SfaqeewAx;eO}yhL8y94WU(tP^lO@N;`)F3?S9*RSV@pBl*sdArw{0t+LdjiZ05- zpyiiUgF6h18j?sf;df>5>@-ulv<+=G9!EGaPYV`8V+O@X=TpRq^nn;|tb?RFN=25{ zsatKR(+kkjNui3X0)$w|8Q&I;KcNDBCQG+SEykK#h%F*EQxi?4S$6MC&hL)+cxQ3@r*ke% z2!pG`mwHGpI4CMNC_FhZ&SgJ9lrKqvU=w2K?F>1ca@*}YhG!sj9EJnLqX4Y+F~hqS z-oC+v&j^o|OcXt?!79$%o1;Zk8LXb{DC!t7ikuN60Vs|Jd zR^+>v5>n_;trs+z5>PC`m`!fxW_IPu?(Ny2gV)^B=&HofG?XM2Lu$73C0%AC9_1_{ zcMA@i5Ojm2+vIiGzNgol?C{J|TdfdY7unh+i}o&DH#DGvz$;;b%6rlo~jOkq$qD6RRd7RtV5=>Nz;`bY{L@oI zU5*2M#g_#ZUso705gl|$RD_Ubl0w<6kv6=?92x13sIO5{WD(Uh3rfO~NlOYuj^vAA1&6{^DwkNRv=G+qrsqkSF)vDlhSI=NaGyc zP03AzM$;*%*kS`q(3prphloIgier4+IU@$jgJ|PmbK9$K*zsdz1}4$eJV@jUblQdx zAS>Ff2ayDL)HK%OT4;_7 zokyBIR@MrY9*UJft1zWa`%q)L+Ks(Mvg zzU_cpGw+27N>xNPJcCVClhkN6JWT~u^h^mFRXsovf=^XY^(G@mf)s*CGy+W$l4%%6 zeBQB-Mfdt9byoZ=PPFNnk14!w zY2Cf&!NZShVRRNPYn;NR?Qv(ZZo0;H3dsmI!ziTDWrl?gC)PO+QY*j@cw^oe9_h#% z9i%8pkcf0=O9KcV6j1|6N7!JdrSsjrb2D1*r!yh&&m7xG^>Rbi$@qqZHJGdCtVZ(( z$P;;7yd5r?wi=4KLU^&*HrX4#&QK^7iDi zXRPaZbjcB-Pj+`{8B+o*+FG6t9hpOAB0wY6a-Ay*U@m(Mch>oF9SmX;7V>sk%fudB zz_9Ma1k5(mzV+bYEKx%{vil~}rUV3#LmF;+1~kag8Y3hb7=Z9T?!^VlVc@1U?IawW zD;BNSuT~A1eV#8mcV%!P@gquHXo*4&i0m%~f^1n31vW)mL8_#M zy2e?jF;RKK$2o$-ktWJSw48Fov&K8j_)b-Gm1c#(4XX zC{aNay_>J9mYQfTcgJyPLfU(WN_>W!te_M<3-J}UG%Kyj-Kz#%K=}}7!Qtvd=mJ6S zV$3K6$N(4T1~)4+i^dvZ4F<Oi%Mfi*>}eZAFk7X9S{M+@kzkg? zVzv?xJWyVero`h!ahSlv2`+bT;EZ0=aZXq>h6RF&+Tlflvash0CoKy(g++0&mcwfo z0C7NiN}A+Eo90nkns6Yza||Y^rdT8@Tu|E>X`*Zz3mG${ljSKwq)m#AGe)CqmS)S6033IcAzK!dsNW!) zLo$Pg7|{jA#6cCs8BGUGVaq68CaA2IO^nM)q@q%pwKADmrll)1+Ga~7nW>qTBQ}(> z&6%YuG|ZHxl_r#?QkydyB{b4mQ#8_PDM->%kuxSt%NeCG$uee2LJ2gakuofr14LOd z6kN8}?$x=&tmYR(TGXW#mLW!EHo{WkHnn97C@@BrL9&z>SToWs09i~yp@fwoM5IA7 zQfzK*wOwwq-Ki!-Dx^`O$nt__Q4L)zX26&>j++LsrVwIBQ80`OS`fW{@b|s>^X>io zH*5I^!10|O%_j;o_yZ#Rdp;xBX=;2wJW){rx)57mTWhb=43A<%6*2u0;Y54H_;`EB!J=4my$kHwS}olT5uGmIUuv?O zTatFmpr>ovCYcz~7V4fkm$cIy80`=m8&GvFQxvUfp=H%$cKab&7HhQ3H>U7RW!`r8 za$BU*kyN@X1&D7(-Igx-#a26^9dL4|eEM4=RI!)Q5Y|L#3+VF{wMzG_B}0-f?nQf7 zd$OU!e#SR3bIQnW<78=D)wJ}wuDiLdvhS6r4F!ifCh9Yk6PS(;zIS{Qs-zi54j*LJ zJuhxgVqUZBYT1vC-Z~PT1Z~c|Wm)qpRay&z!|t+?2CYzmF;@erru68-b8nUC>MBdT zCg$CVX;niO7Ks(hdsL=u?e3jwd0=89avnk2%_&+FE`z3B(%s$aqkGZUQ8fnVLh+7t zDQs5uXv~zL?8QXPIJ()XX+#1}NF%}~DVp~I(E8n!Xh7ni!^7uh**FKEN*E`=6G z?4id^^QW!6W#Y(6gy7y%EIISivw08;i}TBu^@>q!wgU5e@m?jd@i^Hnf)navwL yS7uDEMvP(I>@qyLFL-Q6rp-q-l-2u3;XgLL`aSphK>Z&7i@744C`cW=wwZt~W_%|A literal 0 HcmV?d00001 diff --git a/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/prod_p_forecasted.csv.bz2 b/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/prod_p_forecasted.csv.bz2 new file mode 100644 index 0000000000000000000000000000000000000000..c793514416cc7ad3304d210c8a16df098d4bf58b GIT binary patch literal 1787 zcmV%7s-OS?2_+Om)Bz@$l_?7K;t(|>HcaGCqIO@xcN}^*h z$zAKTj#FT*FBhHWgwphS&NFV5+#+LOtYdtgOqDQ z+||o=s_2*Lv@zkC=d%qGct@azo`~Vzu^dOGX_bRKlsyL9d}Ibj7NZF$^^6?0j}I_# z?6!3-<~V~CLp`?MfMO=i#DM3oe5(!ZH{2aq_l4H8$VP^-VR#@Q(hh_j+8Qg;^HF+G zlHg*7_H<}ZiWJO&uZpPi=%*WQGkblW8x=|o4TE@Zk3|#*F(}9-Br1L%I@1d^hW2`>e48o5j1O!=-Z8nxi!~^#3U%&+}ax0`o?oI=XC+xWKfU)Df zFRt?&7|o90jos)YFQK|M%Y-gd7{XC$g}BmiV~lgB5j)=mL4UFZ_Ml$9xE zEYzr`TV`t|CQ~y~nRTQG|aP0HdKtv%!xLV%p|5IGc=Ji zBM{j#h@~isNP}XMh_x6Kp4zuY+juvKQJ6%c0Skw`<0Gae6B`grV*!n4Xu@VQA4s67 zkur>siVGVNsRBg!2#36QbA#r`CNpI08RSE21U+{`k=HR7ZElETw_ItGXuCEXbmyNU zE&BY$@{i{IQT!L@$@p@aPFt3n_al}d=_cr7Tg;T|aPFhPmP1JsODvWyla@^!29A=o z6p&pCjmjE3n$0Xt2-_)QGaX?x6w7joCIEz@5&|L`q23;N$?dz|p5I_lvik0qUQ><} zI-a}s*g}sc#Wu>cs%fi*?2d-tCx}}iLb?~z9V{8d*_P_g_TqtZYr6(@4x^K8(VI6i zCsMAhXFbG43sm;bbuIuwjeH9jS>T4>>Fba4=nWn};l3RlY!kgplqn;z`>Y z^#$dyeqNX~Xiuwmh7hjmVbSb{Hm^dOOEk8sc}nqEns+VsYr{`xIiphI6rG8uv@~$J zG|>(RAtGs}nmAm!Mz15&EowZ5K22`Am?jSsVql&VgCUWb(75JgvR7?jRjQf7vk4)U zdy|F2dLCAd=`>imMXW<}4iVuDL81>DmrS*pTsvbJ+1ppbZ*?)kD(hnH@Tw;%B5mB; dnVZS`OOk%5`bW>|52Sy^+>uTcBoh^?qX1ekR`>t_ literal 0 HcmV?d00001 diff --git a/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/prod_v.csv.bz2 b/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/prod_v.csv.bz2 new file mode 100644 index 0000000000000000000000000000000000000000..79c31540fdacc2a4b4da66b1b35572beebe0e697 GIT binary patch literal 116 zcmV-)0E_=ZT4*^jL0KkKS@H-gP5=_KTL1tM00Dl8004r4FaWqiO*I+~JwgBg1u8~O zOpP~~BT^+gf;56WVhHgBZV1E?!U*N05#0(|K^cNF+!2gWrHR}T)Dg@P#1V)hrdH*n W(r%P77vcjE@pmLsg$WNJg0$e-SSMBh literal 0 HcmV?d00001 diff --git a/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/prod_v_forecasted.csv.bz2 b/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/prod_v_forecasted.csv.bz2 new file mode 100644 index 0000000000000000000000000000000000000000..79c31540fdacc2a4b4da66b1b35572beebe0e697 GIT binary patch literal 116 zcmV-)0E_=ZT4*^jL0KkKS@H-gP5=_KTL1tM00Dl8004r4FaWqiO*I+~JwgBg1u8~O zOpP~~BT^+gf;56WVhHgBZV1E?!U*N05#0(|K^cNF+!2gWrHR}T)Dg@P#1V)hrdH*n W(r%P77vcjE@pmLsg$WNJg0$e-SSMBh literal 0 HcmV?d00001 diff --git a/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/start_datetime.info b/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/start_datetime.info new file mode 100644 index 000000000..5e520426f --- /dev/null +++ b/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/start_datetime.info @@ -0,0 +1 @@ +2019-01-11 23:55 diff --git a/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/time_interval.info b/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/time_interval.info new file mode 100644 index 000000000..beb9b9011 --- /dev/null +++ b/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-12/time_interval.info @@ -0,0 +1 @@ +00:05 diff --git a/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/load_p.csv.bz2 b/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/load_p.csv.bz2 new file mode 100644 index 0000000000000000000000000000000000000000..488a31b2a6bc45530b0558582ef23207e2360991 GIT binary patch literal 2645 zcmV-b3aa%&T4*^jL0KkKS-LXnoB$l`+W-I%00DpK005)};1HrYqJc#K6i|8aXaTBF zO!Yk!0)e*8t1SX03x=nVGOC`4VAVeaB~-+~rkNO+n1W3xCe>8Lz(rHrRZu1)AX2G6 z6*Vej)i82=_-owo-QFsPs_QiO^W}wRj8oma7Y#gmVeO%KdC<9RRJ*K=!<=egNH%!5 zF&dRqEQDRBIj7ogZzG*7B@Gj)VKw{P)Qr%vdFCnCtZuQHk9FnMK*8A`C$3h_FKz z3I&8Ll@)Lyudvqh>)HdrLo<}gL3#&BZ8#sXRTTZz znIVi~%wn<0CTKudf~bfwJJu*O<|vS`mO$JlNe&mh^dvH-N)L=&v{2+wiyG1;&@*mZWG#IA_$7XWbBiq#YP*{lTZr-06zN+ zF$1&3_qomGJZJ-lz3mU$c`-*lYpSM~?@yA6MwzijprUJOmQ<*dhk|%Ktk5V!$bqE* z>N0gj6fy?n)D0?q;D8g}@Rs?cHjZfqk4(Nfy?7|T9`xyUJI$9{*}&+}spg*h>P7L^ zhLWXI6Ov8_vk8n~8;lVIlh^_C7_+SSMJ=`kO~PscqDo8vKJnh0R(3a{k+*m6cnS>~ zo$R!M6mT;Wd|OK^Wcf($yU_EkkD5^6(4mlz}s zd&l1AxzD^^{ZpLRuinG3fueJA07#% zRYhQUN#rAF6=bq;i7;8vSUC@FO(`a%z=rzm*0lX++{4+^+{c^j-sw1!oUfhp-F)-o z9hIeMHzI56;PVBaP4wk~v3JUa%Sy@2fr?~eh$yleix~_+RY@%4BE|<+BhgVN6H-kv zA!L~cckX6CedvzfY}Q$dRd{hGA3*BV@w5Y%NFPzSBjO$}8IV;Cm>Bj4LnbVk#Z^hE zBEeOdf-pubSb;)t`4v<{u~mzQjjSe^FwrJW?*{k*cq=zD*D#krS>iz|R7Zh>%U5|+ z@~NnKKJ_;;Xjo}pVs!2SiUugeuAwoOHl#sFjEe+D1rAP+z=(8bw*zVcqd|u9^30!l zAOpM>yDF)&o*A0f532!(mZbJtV0`@Jt(`}6XwEa2!1(av&j9&UGOS+z z#gQP(hYI5vOev{=AOnsEfNBUB8@g(=8pcy8W-`i|hD(x%?|cW8bB;`vjACM0j2NbT ze52-8SWIE@Pm|^{jAfWi%Q9a+ckBbtAul|YUU-W0#7FES*b^UqQRF@J_X23pSuHFE zB$iT=QiYJVSp)veF+U-eSYI$6Wy|m*V2?r{kA5lO_ek^4Z*8jzYssrkuf~pe9CgLI zt4+2$oF`py?r}~!Qn59_uoDfRl&|WxYsMnTc*vERPOGaoGoistt+m(hNxdfN3SCFSg*6}`!;BL%=&BAAXIicXlOcp@Cv?l{w>t+YS?FEQT{9 zD){((shO8m2j3!fPHFHTIezV>ZMH^5j5Vf&rj`VvAs}`zITB#PV8&a1badNmc50>e zkbB`@3Gc6OeNL&ZTcgbl(=(S_#U3V zWm8h`*q@}l>o_#+tNG_on@^+KwNDQ@){84$ceW4PezWNF=%?Qr4eQ|y&(`*=KXV{F z1Ou*(%}l`t9T|rL6Sm95u9sJsF8b@N*=JL)HHLPbd~`Y&M`{z^8#8|6gwV|(gSoqX zaW7j(#68Ii>9}=<40#J9@#z=Z%vT9H z+4U;0`<4T>G68%k#h2!jik?aR?A?tVDt(qU7(>2-n@~cO^oKbJ=<}XXT+A`BnQ2w^ zc@wl03N*AVP1tz2)o57tj$PB5mzJLqe$54trdCh8G`{a+7klG(&d9eXoWF94>I70$ zgc~)ZT=$-ReR%?~)s_wQ@e0B^*`#aY)kzj>9 z?DT}Qg0TH_VeeI=8GI?hr(*Klvo<%CFDwV1_WPdh@IZ_pli*WC{E0;lDW?wZF$=HW zOIRj?-;hn8nPqp6%#~l(eGH*S3uqxb*EpEi-R8=pR!%PhUgg7rIKyOZ+i`ket_nh2g&Wge^1@5A;ql>hYlEoKPtg)+*<>(5g;3WR#gQp^xYUiFF6La&ur{OZ1})Pg$u#558b`q zxfvS|@gdt=P%2Rb5`E(h z&i9F1ntE5x6)A_Te0g1`k6NZ zk$8Fg3Iwgsk;9lZJIS@A%hJAq1Iz;OWI7roX=(e1^ zMrIap_ZZ_DeZu>AW__dF&cU1Pp$;|=D;wV0>y%4PUhOEKFF7>q4>PmU7B=cSFi>2{ z>3y%P#WdAOwT`^#xFm^S<;Qt^v5<9MblO$!X~Ac@_ftE3qBm;p5^4)>=A6B^47A)b zKD*(O;pVYT#qIOH?-*&F=oBxp*S@1v_uItI_;kI`do9h&6n%;FFz!gM-So&#ZwL|V zh;jBX^Uiv3S|Ga-+{3aN%XQO#XYr|L-5*{P2HN|BJaIoG3_L8Ffwo DhZ7Z6 literal 0 HcmV?d00001 diff --git a/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/load_p_forecasted.csv.bz2 b/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/load_p_forecasted.csv.bz2 new file mode 100644 index 0000000000000000000000000000000000000000..8e341212e850a9d8610c1a7cd293d6dee6f528d3 GIT binary patch literal 2221 zcmV;e2vYY#T4*^jL0KkKS<1~5%>W$mTL1tM00DpK005)};0|8iGwa)XZH*qay=8X3 z2D*3IAZR;2pE*9fUiNZ{+30gItTf3nl~OPSkkrDeVqg@iKT$;?wE#(^l6k7CVqhXj z$WcuIM5alys+gE~50Q-e%v^U*1E6n43cXj89d&_ zb+;RL9A>*U_NZ%_)x&b-R{EwJc^`0CZR9yl2e<~AC1tmpDS>aJjJx{iyWB?&k#_Ti zKQ`fKQv)Kxat@3M0s{oGIUsTnN>rgdiSE1P_h18ZdxmMUVYaY+(~;5?R3tKI!ANlO z8+wNTFhe9mz<9`#F-aoe86fzC0)Z$UE8rg;akDCg4(#Tm=I+9@ob}vUS3<*38xX7Q zR~#7ZA;@V7bz==j#&?tI`NdV%90qjyEi-YMTT2e#}2PAf*G`r+>OasR5tj*s* z%M)!n=|u2tH!~H9`tWN?ZuehwRmU zx%AWYWmy$IZh#au)_ptTvdG&f9XHAubq8kcvqs#4BaPuWfXo^&uB*U%-q*_V`$an|QBnT&!EKOlF zj6+nRDMN{%o1Xg)=e?Ed`!=r*;m)FwVsO&5qf4&T2XNuZUwTg-g_)?zEatP|JWi;x z2T}x65ViP>H6%zy&?s6LiK-mVUHduhbDEfHX>o{IM;}epPjQsMKf)Yg0NVoFrS~9H0t0}dm zg}qbQvFyEzS(6pDtB^z| zrFr62=Zc5qq4r8M=cMwT@jh8#QkFqsEwU7{z!3;i(4UIT(^AI1{UmY-_<;KR=%i0r z13W%L)Gb7?jfJI&OOF-9mnDIgWZ}siIdVC~T$daia5%YgILWO`V;TqJu-b0LQv?J# z$x4&~#}f(>OBkCF(8e*KV+K+d2@R&bS7_?H-t_9amw4gIaV|RRw^OQh*Lymvw7Pe$ z*C;QPp%_3VDJ#2Hh9ua=h9uh>XhUooViRo)8c1woXd4<}(32ZDaE#c&#~F5tK0H&h z=M&M^wKW-<$ZJ?&&6u+>i)Ph(dc9LIrjygv#X;X7;yc%E2GcAJjc9s$J&R_THfg1` zmKVOs>TLY3ONq`oIGiPRlm2 zyJkz6vxAbU5Hx27f-=JFdh*&%6P@9wG)_Z9Z-G*@+N7dPE(Ltn*mRXt6{T_Ox3qY` z%?(+w@}Gn7dG=|C4a~`dmvY&+?9Mu)Y4()AVe_JF&)gh08!BhgQ=Ugsa9fgU^Q~o< z3Pz4f)-FZhP6~ixz{QiW>=BFF*R@{aFL3po6f&=_!Xt4gg7w%MBFh$@8EquDT)IgI z5Zi$8%Tzo9eQ=7gWI!dVd{C8b3MMwJfjh_uh?_4w8N)4R`e)hrI0a_Qw44eZKXAC6 z3^M2IMiqerP>r~m5<#GL6!0o~P-65f*l^lPgM%ePI_XYHu+rSN7G5E%zIWikdr!s> z=?|s281y+FO2wUIRQn82$QUdTW~hubW3$pfRgY>>6f)7ayk@2AW&cfL{c(CVgmtUJ!D2iVL9h8)7$TFhE0$#T#P;h_j2Af%cZ$} zC|O-yot$y&7T3M)zhw_sdv6(jxsE40wdYIq<_G8PFP_aY#goEkFApK)-X+-j6Vn&l z`!4hMyO}iLoZEYv|G=6%CKGIo0*w53l(C;i%Q^fJ-~Cs!Fdkq`g-)g zdGpPz*lvA>H{M>*V=jtJ30unQ=Rq&DA`L0%3p=i>mcfnmEd%PHcun=XVhJVQF6o=- zJ3)<%b+=gQ- zo@l^}f-VEsFJLCnV|FHz4oHoVwo6;CV=H2)M~gPq)Ju(zQRF;t-+js=@VVxikFYD3 vP;t{4ShJ`M%*=Y+_5Fc`95`8R+ds8K@~C}*_(guCe+#)HoG3_TW{Kv2nEx+F literal 0 HcmV?d00001 diff --git a/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/load_q.csv.bz2 b/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/load_q.csv.bz2 new file mode 100644 index 0000000000000000000000000000000000000000..887ff90b5c5059820a46bc975d3ecdf6c0037e26 GIT binary patch literal 2311 zcmV+i3HbIxT4*^jL0KkKS;M1_ z=fUrqoWn6nrBtxc+IVVt21<%(162GGHB~V%5;YWnXaY?r%1>2O69E!U6Vjt0pi-vQ zM3i6;m222d52X1#NWr)?i}n(5_9D&-7$3_~J&uu9e9H!`5mqUEzPMj2)X>~c`^QpV zSnC$SU#zbxdizI<$+k3FH<-X(73>=it{)tIuO%2X=6IOsBpcytomfkcX%zFL!|Sy$ zUWg_WZE6IUQ-OI_k}?3~CN@MTV_yKk1HpVji|9g-JtXlVX?MSI^}Kn*nNv*&ACK0) z7o6u0p@t~`r5r(jg4S}*6D##Qo!V!RAL*N&b zo$O;0bo0P_#-FMYEMSokH6%e4zZqxL4Fg0#_zx-yho1?^hZtEHAS7VOr66sBiYh}% z3B(R6Z$n}bT2#s?$0V$)=Fuhmd(Utj_ceL7=w;pSc-~FhNo4pZ;T0cKj5sV2gk(Y> zg3e?ixJP32S{*1vEEml1m34S>w%3ww1V3L|@o%?JEUxlpIU5JE{T#niYLi3hJc=pm zEad#y2V__zU?Bj6BzPgjwGEqQ8f|QPWgPZM6C>No5T}| zvv`wGz@}X(GA^PM)2Zl#5uAv5067u~5+M|Z$Y}_hN3sJ*XcLI}le0T~)XzJb#0>AS z@8JoI8g-W*Xd8%H7Iw3-Lvlh1oyrO#PTNYl2oNI>IHszdkn<3*oRS(6Z@uR;7+v3& z>-zBgYVS^1nR=Nxsnbl(QEDbcN4+5+N*IGoBO*2hmIG8F79JoAo}(_kcQ*R?;aktw z--yRHX+>d)n6ncL5Z??$e5&whL1KV|1`xs+2UZZWh{9~J4@g8kN;{Te?~keTQ;qYI zVEnght+KNmEJr2?te9!}BRr@)Em9F+sT73kl2{!G(IN2)0fFA|@KTGllH=TP+^gzg zBzP>(XbA&e<1(O&|BgfDYVT~Yn9W6 z(qmJl&V?lf3?PwU5P(>SC%dHr(&vUHDQGMhu>oRGstg&BUkLplt!S-mX)Wz*qGr|=yfg31L+7EkXC0TkJDjXlKE#j4;=Y|%%f97dYlEse zw6Yo0>aKEhUawKz9ZR~ML!X&4L+U8}-r+v9eD&oX9(s8W>hB(_oH}}XPIPhN^p5E| zPIR44IJ%ds$aTjhq*LS6y04Sx6ziOmuHw4qMb+Id?n{S|@#V`=SkTM|ziV@5coif6zcJ)^~#kH|uwFRn&Qoi{G#fa>7yAjU7@?Q1@ z>SvPQ2AKBZz3JGAnK6lo9e#ZMjok~IPq#C9FrdrxP-3v7ZErpWP7OLIcWjP&GS23B z?OmfQOxq7&Se-KDd0}?#i;eronJ3DiqN4#Au!rOuWr8B83J27x5}<<>RUNfel8A~b zD+Lw`AfmA!%&1g|qX7|!k>9<0_wRi+ULd1z$<*#`F?p z-Nf*3mZ#^bz?YnQJGUuudR%(#iThY%D(f8rNIoPI1DDmZ%k|rXToFzMlE|WHUS`*& z^y;qd)d*WUPR&+s1KXNA1zYA__Dj6n5b)Q|&pKwtWO64-XChkXvJH6egIOt~X05W} z%)B#!AgfY(f(i3Lt1>_E_~~y(0y-nQf1Px-cjx?4-<%Apz7Dt zE?(WE-uWwO8cmakPdrVCAxo-TzI=Va*1BkB-qSm#8)k0~&@!`bKIu+YCWM^`M_-A< z!j|z1LC)#78GNCHXkx>+*S7`Ly5SLx9WPjKs$uJyuuFTW)SP_hQr+uTrd~7cVZRvQ zw}&qudhldD6SV0OPirht)x8pdZ)U=$9v0cSKFe z`IyC2-8sPGDyGfTyk<GpT3;`@h2b&-vJ5#!#o!!ieE zACJe|l6P9#bJibryD)DJHlK~O?;j8z0+K|6Cu-D7fobag->4*ag+cM__jbpD*s6Z6 zI#(_D`l?>IGOz3e&5*0e&g zqgqv7%JRH8)08RizhBqxxP{ZNU3r76p)Y(jlUqkU7-I-6E*2K^RtU&KqQ8HyHFu9`Qy3+U+&>G-iZFOP5PE~@BZS?Hz h>-0A&Zf<1E&1Cqe@}Hso2jZXN?ntK!5*gTa5g-h~W+?yw literal 0 HcmV?d00001 diff --git a/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/load_q_forecasted.csv.bz2 b/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/load_q_forecasted.csv.bz2 new file mode 100644 index 0000000000000000000000000000000000000000..74f6595f6bffd4c371ba1cd3ada710da571c2040 GIT binary patch literal 1884 zcmV-i2c!5xT4*^jL0KkKS#<)>PXHTu+W-I%00DpK005)};0#@-udrEm?XtUWxgteS z19#TFx5P%JRw?(f9Prab*)>!~0VFg@`l^#A14@3d)9K*y zVeP(hQ40 z>L*DjWAUfE+V%J#Z4SH;N5)KFGJF|JMS}K93zuM`TWq>6hzsCuHQwio(V0JzhiQT1$jU(1+VI!}k`x z@7@9zwlTU+O$U;=2Tq9aFj8f$ZTS zZJBVlRK7Nix@cH<>O7N@Bf(%F6IDecDisLWM1sVOSrx@_aTujk=!Z|Z_U-kVynwd~ zlC=WWLgbBEwsJ>KN0MOhfuX9b8f21@Mlpme9B>$=Md~k4xbM4@-0huh`0^Y&k>Lx+ z&K3#HhSDacq1Ui$RVadkAY_J2fC&PCHbQzkYgm`O!t&Fpq$cJ8ny}L$7k)kywK=J7 zS&5Xr98Xl*KSIp;WA2`}*=M&r6daS_I^1S@Dc z76Abwl8I-`uYJs4ch4>o>0VtmO<}DxxSHvqgS~qPwLAh;Y?IXdN5c8x_Bl>DY@4;U zX`@tWsf?yrSYXMOlM@sLKQf}?;6a3pNWu_|2>zQ^v?^7pUHnlPehA2bvI>ogA4Mt8 zy_EaBBk0!3zTMqL&9qIl)h)AG4P>opk710CqMn5xPSAMTm_$rPwF)ar1w<%NY5_{6 z5v@XsMToScKnqr=f#Qhsvq^a6c#A28ZkD53G{VASW)=~xskCm(Xv#88Xw_T0D}qlM zEs>d33I(W*N>mD!sI*`NSxXG1h6@%H!IX=sK*9r2d?Lpbgcv}C2z;e!Yiz8wsji&q zbCjM$uW}6szOQa0x^-NKanqG`$4->fV^np=4vDK)((A4`t(!I{I&sP3se6RkJw1B4 zM@~Armrfk6M$Ju=j&yW7>CRU=>C$oBIZorNlIxCMDOaqa>Uw(~j;^@j!tNbi4t3GW z>#i3|yQt#pjxK|{t|vI<$m^XRN~_o7^XKEUd*|}cKaOS6GfYuk`E&evzs_MvhhDXQ za(s(Q#MCkzM4t3yM4BQxDNfT(n#e@}P-$L?VFD#f-4jElQT6l=>T$%(8N5jv+!?^Z&F;Brp3J>%zS#XUqFFfX7>+MV z5E?N(2d9DJ3x4n4cRt^`_ul6E0BIPIg^Ys;i6Mgl1}MUOF+pNMREUDGWSS`zkU-vd zbGBjLZTxfLzMp;9JTG)!zA9cwInB5*d(b<8K{(xQj$O&MjqAGJwcwy(h6G|$tbo>n zYe@uvHU?-=w`nV6je3q7BQYSfx9UArk8$I+TC{+>(uL7SE@N$`tI(A`w7Jz zw;dOo)sJ%V-e=W>Qd#bBBrCkQmeLf(vpx_ zfMO-*#eA0>=P`^JuAfal@;;2TPCnPbh9d>Tcg!M@c}oKyyfBpnV#KJ3%a>qvL>e%6 z6fAP5rWQEFcBH(S;h6J-4aiI4KOCW#D5=RT;K0vyJ8LVpGk{^98POs{&@eYBY0oH; z;V|1@4Aj6e$(4L0V_@2pxf8*skA;g7@h@jvWwSiwk;&})15KSec=vX3{i+|8 WL+lU2EB2^=3%MekC`dYiXQzP4OppQq literal 0 HcmV?d00001 diff --git a/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/prod_p.csv.bz2 b/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/prod_p.csv.bz2 new file mode 100644 index 0000000000000000000000000000000000000000..a8f9567a0e415f8a0936aba62e2649f08d4cca1e GIT binary patch literal 1867 zcmV-R2ekM?T4*^jL0KkKSz#ifWB?DuTL1tM00DpK004r4U<;)u3}jM;Qr`lVP>2wx z-teM^gC#{YFx2pYQ~*%ZOaKT`5;Z^r5Fs;Bppz*ms0<4}ef##HUv&gaUk&|v ztXB5i_4ic=yR{iB-I0g5@0x>Y(Y@S?H>+`BsnszCdhSdFF14qc;a68jw^J1ms?K@Q zF;K0WW?pWi#l6yjtm?^R-i zhK}xK$;q68_HyP#VDcqf8Npn(mHCVIk_7?p4+Q*f{LYzK(b(?nTf*OlcxZch%KMJa zlS9dIli0}v*fQC4w=VgoC^;kSi{EfPov12+r?51RN*Ra1^EZR@Eb-(`S1T%E_6_N3*<$5os4^34~EPxh)%aWH>=O@UG5um~8cd0m3rI zBKkuajx7hsuP+lo;q<4h?5L_~l{M2uBi5mU_~ON>e8We)Bcheqoi<>dqv%^yUV zMQ-VIM-mAnA6g`m0f2#4CTjMGtN_7W@(c?E3RIy%D#5ldEXwBC*;+$XJA^1|AfHq8 z2}y8wpFz}?_>!rNqRXX(k|FXH>ls5+99VW*K`^)=f+xUBeFKs-u7#4J%^;dKFc?A<(e>&Z zQ_pcB894?$p`%hHl(1X(F&!8jL81f%0u9l7S{Ji+@K?EIS)pi9O+F|b2rNy9UJV5i zRHtz}0goG{oEd&teL&hVAQhl2kV@icP$ZIkQ4J3-QHcVzQ_8vMIMLI(;KNAdRtWJ?$KEdvV-JK5^J#&~fPQMLp5;0gb-`ZLT+%`9P==190x!lk2!l za!FgmxW{;|4<{R<6NopC@*a1vb?1>p+qP-P2Q@(+qA!F4!Q>po^LE`KX)mqhAoN`q zIjoZrvGW19(F}3I# z8OdS9Md<<>aNz|8cEH;bV4|fm)B-K35f)B%<&Hul3kh{KQQMwK?Fi1f=DJwDS`-!DT-zZs)7lLBA}XxnJ6kC zrh+1fnxQBPVu@lRpqZ(nN??$pfQTxZ3L-)!C7MWz0Ej3kB1nn~7>J0bj-W4)fxz!+ z$!HO_R0O{EwsFp5bP#Y^Io+~=iY_|AIWm)h3uB(*!35z5B^OT3*12{_ZYv$2uH$y( zoJEl}hPA$_OA^vORb37oOv4;U2xA8)YNExoIrzMAbDXw-mD%QUa>bGEvBQ*LmC+3u zOCY4dBv?Tp1H7(ys^D^|*<8cBR7S)q$DL|_8;o`6$JPscwWoD{ido*TGB?z$w8QI^ z^J=wKHY+q&E}64(b2^mgbR>MF6{KkzXquv_r<6HRO<@DTpL@f=a%X|^qH4Gv8*mp` z!KUtJmg}y`kS@&Z+%WYAT`xl$kS97*a2nu6MV`W>yh4)D6od(!8D&VDFCR;4j z)Y;8eA)Ip1%n}HuSmk(!7l9`7S1`M{Z(7H7)p>Go+;mOo<|>A6nDL_yUdPumtBqB+ zRX3GRdEK=GxcM&S0)cd~Df8^q;36E$ z7ds)gL8(L*s+H#F8C6}7X+VnBWv$b-vBjX19y-ILheWmu8J>N)J!C>BE+a3PqvUR) ze0>PcL$;r*X^bJeW7vH)iWAuTcBp67j FSpeJUU9JEC literal 0 HcmV?d00001 diff --git a/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/prod_p_forecasted.csv.bz2 b/grid2op/data_test/educ_case14_storage_diffgrid_diff_obs/chronics/2019-01-13/prod_p_forecasted.csv.bz2 new file mode 100644 index 0000000000000000000000000000000000000000..8a51198581e1d45d07188d2ed11b4e0c2347e795 GIT binary patch literal 1710 zcmV;f22uG!T4*^jL0KkKS?B#m_y7;Y+W-I%00DpK004r4U<%P67R_p^Oi#K1e1s4U z>)6GZ+3q{xriqxUrY6v7geIt_hA3&K00f?@sL=eR076MAKxhP-ki{whj9^Q{PtN)E z2X8RF!|QQt_UD81`?2{YLt0OivP!hgpgoH_&sJs*Bq_sJU$`T%1u?-mdGhV!cwW5A z_bl84lscHh1pk1`jwHI9OhdDpoAfbs*9X5^`hZb`x{cMSwhLlj^C` zj^$t#mcX}2$lzFqhY5oQ;1_P!=wN06p8X%Px-x1S+L6eMU6$&qccn@y2C>iLK1Q8x%xSeagn* z(D)Ho+pg@Y4GYD@a||r7vWoR9K^bFS!mBeP7=hGN4?7rGsw<(2qO(Aa?(E&6A6wzd z=AG?W(ZVo0IXiCPZtl%Z1Vw3g4S-Dr>8vt0ShzTBhe+me|^3#DmCL zRw9KUDLStUG&I97$weke8YNy*IFmB_$;=Y6={fRRdG||7n1yie74Dl1((v7!=-q)G zLcP_MLhC7S1iOG%3}-JF8>=B8Ia(0;`=7M1qOSv!DqnyKjiILX;P%&h1i78Sk5Q}x z2RI}_Q6Le(4li!KW;>KIzEhN?Hw&rj(&VDL-@9C=zaHO??oYlw=rwW*CKgEejpy^JqFPj3=^iN8Vqa{6;BF}p&jC4Jt|^j zZc!gdG?){h@Ieq;7`aq@K!@)7d~9ae!34z`-%F=Ms^?(q71P|}?UpQvpP{2_HKtaR zQk9x&WtnW6r8bhJ%%+txibD*nkjxTEEE15&OC+)If*hVXEn_Chv-Wo;+Z;}4<1A*y zCq_6e5yXZdI*qyqaA!hNIP517$2Esp-qfi|5lm@`Fr^umDJ0TmB+`_VMv}%XZIX#2 zW|}0V%`#Dq8Wg0AnVL+S7@1>587&r)EL5S0qJ|-$Ao&%4C0`HUIomFhakXG`Mn4Q2 zi?HwqVeZQ@*ra0vq>~avkYsxX4l6@BHqjV6ZZt`Q7|zFR@>?w6*z1Ra*zd&y;YII1 zEY6_VDahgpr)6;kUvtaR8wQdNQOQQ>s+dr8e%_a#)I!kf4_>AL`e4_p-$RP+_%GKop>>y^NEG2R2I)zO*HjaOBq zTu4$^&bTm(?|VEJzd6qYk&)gTCIYj(@3!svW!MC;fgX3HkQ-wo$UGp+9mlb4q8L6S z74jMg{aA;>8VLPb>#jD1f?w5%f@jr9@R~T|iGwY)(ZsR0Qw7<_7iSxp#d23ExtAwf zxx1WesMitPiLM-gAW4SqApHlpd93E`YP%cPlziOX8^RT)Q}$*_Z-tEZIeD^a551v! z%Ts#qG4x^f&cy3@13d None: - print(f"\n\n\nfor {type(self.get_backend())}") + # print(f"\n\n\nfor {type(self.get_backend())}") with warnings.catch_warnings(): warnings.filterwarnings("ignore") - self.env = grid2op.make(os.path.join(PATH_DATA_TEST, "educ_case14_storage_diffgrid"), + # self.env = grid2op.make(os.path.join(PATH_DATA_TEST, "educ_case14_storage_diffgrid"), + self.env = grid2op.make(os.path.join(PATH_DATA_TEST, self.get_name()), test=True, backend=self.get_backend()) self.env.seed(0) @@ -32,6 +36,15 @@ def tearDown(self) -> None: def test_reset(self): obs = self.env.reset() + assert obs.storage_Emax is not None + assert obs.storage_max_p_prod is not None + assert obs.n_storage == 2 + + def test_simulate(self): + obs = self.env.reset() + sim_obs, *_ = obs.simulate(self.env.action_space()) + assert sim_obs.storage_Emax is not None + assert sim_obs.storage_max_p_prod is not None assert obs.n_storage == 2 @@ -43,6 +56,24 @@ def get_backend(self): class TestSim2realStoragePP(_AuxTestSim2realStorage, unittest.TestCase): def get_backend(self): return PandaPowerBackend() + + +class TestSim2realStorageLSDiffObs(_AuxTestSim2realStorage, unittest.TestCase): + """add this test for https://github.com/rte-france/Grid2Op/issues/518""" + def get_backend(self): + return LightSimBackend() + + def get_name(self): + return "educ_case14_storage_diffgrid_diff_obs" + + +class TestSim2realStoragePPDiffObs(_AuxTestSim2realStorage, unittest.TestCase): + """add this test for https://github.com/rte-france/Grid2Op/issues/518""" + def get_backend(self): + return PandaPowerBackend() + + def get_name(self): + return "educ_case14_storage_diffgrid_diff_obs" if __name__ == '__main__': From dd365beee6b755e5e0ea7863f90317a422f38cb7 Mon Sep 17 00:00:00 2001 From: DONNOT Benjamin Date: Thu, 14 Sep 2023 09:09:53 +0200 Subject: [PATCH 05/18] update changelogs [skip ci] --- CHANGELOG.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 56735a746..4355acfbf 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -33,8 +33,8 @@ Change Log [1.9.5] - 2023-xx-yy --------------------- -- XXX - +- [FIXED] issue https://github.com/rte-france/Grid2Op/issues/518 +- [FIXED] issue https://github.com/rte-france/Grid2Op/issues/446 [1.9.4] - 2023-09-04 --------------------- From 9b46f2d6b71f748fb1829a9392f7a953b31a6564 Mon Sep 17 00:00:00 2001 From: DONNOT Benjamin Date: Fri, 15 Sep 2023 09:29:41 +0200 Subject: [PATCH 06/18] adressing issue rte-france#523 --- getting_started/01_Grid2opFramework.ipynb | 2 +- getting_started/02_Observation.ipynb | 768 +++++++++++++++++++--- 2 files changed, 672 insertions(+), 98 deletions(-) diff --git a/getting_started/01_Grid2opFramework.ipynb b/getting_started/01_Grid2opFramework.ipynb index bd11a4be2..8a6e1745f 100644 --- a/getting_started/01_Grid2opFramework.ipynb +++ b/getting_started/01_Grid2opFramework.ipynb @@ -187,7 +187,7 @@ "\n", "custom_params = Parameters()\n", "custom_params.MAX_SUB_CHANGED = 1\n", - "env = grid2op.make(\"rte_case14_redisp\", param=custom_params, test=True)" + "env = grid2op.make(\"l2rpn_case14_sandbox\", param=custom_params, test=True)" ] }, { diff --git a/getting_started/02_Observation.ipynb b/getting_started/02_Observation.ipynb index ac9a1d59f..bb2203a44 100644 --- a/getting_started/02_Observation.ipynb +++ b/getting_started/02_Observation.ipynb @@ -35,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -44,9 +44,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/donnotben/Documents/grid2op_dev/getting_started/grid2op/Backend/pandaPowerBackend.py:30: UserWarning: Numba cannot be loaded. You will gain possibly massive speed if installing it by \n", + "\t/bin/python3 -m pip install numba\n", + "\n", + " warnings.warn(\n" + ] + } + ], "source": [ "import os\n", "import sys\n", @@ -56,9 +67,19 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Impossible to automatically add a menu / table of content to this notebook.\n", + "You can download \"jyquickhelper\" package with: \n", + "\"pip install jyquickhelper\"\n" + ] + } + ], "source": [ "res = None\n", "try:\n", @@ -99,11 +120,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "env = grid2op.make(test=True)\n", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/donnotben/Documents/grid2op_dev/getting_started/grid2op/MakeEnv/Make.py:420: UserWarning: You are using a development environment. This environment is not intended for training agents. It might not be up to date and its primary use if for tests (hence the \"test=True\" you passed as argument). Use at your own risk.\n", + " warnings.warn(_MAKE_DEV_ENV_WARN)\n" + ] + } + ], + "source": [ + "env = grid2op.make(\"l2rpn_case14_sandbox\", test=True)\n", "obs = env.reset() " ] }, @@ -144,9 +174,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2019, 1, 6, 0, 0, 6)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "obs.year, obs.month, obs.day, obs.hour_of_day, obs.minute_of_hour, obs.day_of_week" ] @@ -160,9 +201,21 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of generators of the powergrid: 6\n", + "Number of loads of the powergrid: 11\n", + "Number of powerline of the powergrid: 20\n", + "Number of elements connected to each substations in the powergrid: [3 6 4 6 5 7 3 2 5 3 3 3 4 3]\n", + "Total number of elements: 57\n" + ] + } + ], "source": [ "print(\"Number of generators of the powergrid: {}\".format(obs.n_gen))\n", "print(\"Number of loads of the powergrid: {}\".format(obs.n_load))\n", @@ -180,9 +233,19 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generators active production: [81.4 79.3 5.3 0. 0. 82.24667]\n", + "Generators reactive production: [ 19.496038 71.34023 24.368923 24.368923 24.01807 -17.27466 ]\n", + "Generators voltage setpoint : [142.1 142.1 22. 22. 13.200001 142.1 ]\n" + ] + } + ], "source": [ "print(\"Generators active production: {}\".format(obs.gen_p))\n", "print(\"Generators reactive production: {}\".format(obs.gen_q))\n", @@ -198,9 +261,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loads active consumption: [21.9 85.8 44.3 6.9 11.9 28.5 8.8 3.5 5.4 12.6 14.4]\n", + "Loads reactive consumption: [15.4 59.7 30.8 4.8 8.3 19.4 6.1 2.4 3.9 8.8 10.5]\n", + "Loads voltage (voltage magnitude of the bus to which it is connected) : [142.1 142.1 138.66075 139.29695 22. 21.13022\n", + " 21.12955 21.478817 21.571596 21.432823 20.750198]\n" + ] + } + ], "source": [ "print(\"Loads active consumption: {}\".format(obs.load_p))\n", "print(\"Loads reactive consumption: {}\".format(obs.load_q))\n", @@ -226,9 +300,50 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Origin active flow: [ 4.2346096e+01 3.9900578e+01 2.3991766e+01 4.1828262e+01\n", + " 3.5666172e+01 1.7225140e+01 -2.7542929e+01 8.1183472e+00\n", + " 7.4602180e+00 1.7347816e+01 4.3849845e+00 8.2175179e+00\n", + " -4.4212246e+00 1.9712504e+00 6.4163899e+00 2.6171078e+01\n", + " 1.4931423e+01 3.9526379e+01 -1.0408341e-14 -2.6171078e+01]\n", + "Origin reactive flow: [-16.060501 -1.2141596 -7.423434 0.40774456 -0.44919857\n", + " 7.7376227 -2.1186779 10.543067 5.6506634 15.18845\n", + " -1.5994288 3.6139119 -7.7159214 1.5654972 7.370694\n", + " -16.11945 -3.0833588 -5.630818 -23.178274 -4.492154 ]\n", + "Origin current flow: [184.01025 162.1905 102.03776 169.9557 144.92264 76.722275\n", + " 115.02098 349.20593 245.6016 605.0953 127.5342 245.28467\n", + " 242.99077 67.37295 263.24207 127.98145 63.482616 165.48074\n", + " 900.4441 725.5414 ]\n", + "Origin voltage (voltage magnitude to the bus to which the origin end is connected): [142.1 142.1 142.1 142.1 142.1 142.1\n", + " 138.66075 22. 22. 22. 21.13022 21.13022\n", + " 21.12955 21.571596 21.432823 138.66075 138.66075 139.29695\n", + " 14.861537 21.13022 ]\n", + "Extremity active flow: [-4.1986198e+01 -3.9088322e+01 -2.3725140e+01 -4.0866714e+01\n", + " -3.4981895e+01 -1.6992859e+01 2.7643835e+01 -7.9793596e+00\n", + " -7.3712506e+00 -1.7057173e+01 -4.3787756e+00 -8.1257477e+00\n", + " 4.4793596e+00 -1.9592170e+00 -6.2742519e+00 -2.6171078e+01\n", + " -1.4931423e+01 -3.9526379e+01 1.0408341e-14 2.6171078e+01]\n", + "Extremity reactive flow: [ 11.560926 -0.54758495 3.9026122 -1.0090021 -1.0585623\n", + " -8.46951 2.4369648 -10.252009 -5.4654975 -14.616084\n", + " 1.6159215 -3.4187043 7.8520093 -1.5546099 -7.0812955\n", + " 17.991196 4.285767 9.055665 24.01807 5.187079 ]\n", + "Extremity current flow: [ 176.93805 162.027 97.690315 170.2111 145.05737 79.05555\n", + " 115.02098 349.20593 245.6016 605.0953 127.5342 245.28467\n", + " 242.99077 67.37295 263.24207 1233.7778 424.4511 1064.1736\n", + " 1050.5181 1036.4877 ]\n", + "Extremity voltage (voltage magnitude to the bus to which the origin end is connected): [142.1 139.29695 142.1 138.66075 139.29695 138.66075\n", + " 139.29695 21.478817 21.571596 21.432823 21.12955 20.750198\n", + " 21.478817 21.432823 20.750198 14.861537 21.13022 22.\n", + " 13.200001 14.861537]\n" + ] + } + ], "source": [ "print(\"Origin active flow: {}\".format(obs.p_or))\n", "print(\"Origin reactive flow: {}\".format(obs.q_or))\n", @@ -249,9 +364,24 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.34012985, 0.36042336, 0.2721007 , 0.26722595, 0.82812935,\n", + " 0.26920095, 0.3433462 , 0.5315159 , 0.4951645 , 0.7316751 ,\n", + " 0.28853893, 0.38265938, 0.28927472, 0.43187788, 0.39644888,\n", + " 0.5446019 , 0.53346735, 0.9244734 , 0.4533958 , 0.4615403 ],\n", + " dtype=float32)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "obs.rho" ] @@ -265,9 +395,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int32)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "obs.timestep_overflow # the number of timestep each of the powerline is in overflow (1 powerline per component)\n", "obs.line_status # the status of each powerline: True connected, False disconnected\n", @@ -289,9 +432,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "load_id = 2\n", "obs.topo_vect[obs.load_pos_topo_vect[load_id]]" @@ -306,9 +460,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "obs.load_bus[load_id]" ] @@ -335,9 +500,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "from grid2op.PlotGrid import PlotMatplot\n", "plot_helper = PlotMatplot(env.observation_space)\n", @@ -366,9 +544,26 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 1., 1., ..., 0., 0., 0.],\n", + " [1., 1., 1., ..., 0., 0., 0.],\n", + " [1., 1., 1., ..., 0., 0., 0.],\n", + " ...,\n", + " [0., 0., 0., ..., 1., 1., 1.],\n", + " [0., 0., 0., ..., 1., 1., 1.],\n", + " [0., 0., 0., ..., 1., 1., 1.]], dtype=float32)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# if \"as_csr_matrix\" is set to True, then the result will be given as a csr scipy sparse matrix\n", "mat = obs.connectivity_matrix(as_csr_matrix=False)\n", @@ -384,9 +579,24 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 8, -1, -1, 10, -1, -1],\n", + " [ 8, -1, -1, 11, -1, -1],\n", + " [ 8, -1, -1, -1, 16, -1],\n", + " [ 8, -1, -1, 19, -1, -1],\n", + " [ 8, 5, -1, -1, -1, -1]], dtype=int32)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "load_id = 5\n", "which_connected = mat[obs.load_pos_topo_vect[load_id]] == 1\n", @@ -444,9 +654,34 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 1., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n", + " [1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n", + " [0., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n", + " [0., 1., 1., 1., 1., 0., 1., 0., 1., 0., 0., 0., 0., 0.],\n", + " [1., 1., 0., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n", + " [0., 0., 0., 0., 1., 1., 0., 0., 0., 0., 1., 1., 1., 0.],\n", + " [0., 0., 0., 1., 0., 0., 1., 1., 1., 0., 0., 0., 0., 0.],\n", + " [0., 0., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0., 0., 0.],\n", + " [0., 0., 0., 1., 0., 0., 1., 0., 1., 1., 0., 0., 0., 1.],\n", + " [0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 0., 0., 0.],\n", + " [0., 0., 0., 0., 0., 1., 0., 0., 0., 1., 1., 0., 0., 0.],\n", + " [0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 1., 1., 0.],\n", + " [0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 1., 1., 1.],\n", + " [0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 1., 1.]],\n", + " dtype=float32)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "obs.bus_connectivity_matrix(as_csr_matrix=False)" ] @@ -482,9 +717,75 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 8.2246674e+01, -4.2346096e+01, 0.0000000e+00, 0.0000000e+00,\n", + " -3.9900578e+01, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00],\n", + " [ 4.1986198e+01, 5.9500000e+01, -2.3991766e+01, -4.1828262e+01,\n", + " -3.5666172e+01, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00],\n", + " [ 0.0000000e+00, 2.3725140e+01, -6.5000000e+00, -1.7225140e+01,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00],\n", + " [ 0.0000000e+00, 4.0866714e+01, 1.6992859e+01, -4.4299999e+01,\n", + " 2.7542929e+01, 0.0000000e+00, -2.6171078e+01, 0.0000000e+00,\n", + " -1.4931423e+01, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00],\n", + " [ 3.9088322e+01, 3.4981895e+01, 0.0000000e+00, -2.7643835e+01,\n", + " -6.9000001e+00, -3.9526379e+01, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00],\n", + " [ 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 3.9526379e+01, -6.5999994e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, -8.1183472e+00, -7.4602180e+00,\n", + " -1.7347816e+01, 0.0000000e+00],\n", + " [ 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 2.6171078e+01,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 1.0408341e-14,\n", + " -2.6171078e+01, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00],\n", + " [ 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, -1.0408341e-14, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00],\n", + " [ 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 1.4931423e+01,\n", + " 0.0000000e+00, 0.0000000e+00, 2.6171078e+01, 0.0000000e+00,\n", + " -2.8500000e+01, -4.3849845e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, -8.2175179e+00],\n", + " [ 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 4.3787756e+00, -8.8000002e+00, 4.4212246e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00],\n", + " [ 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 7.9793596e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, -4.4793596e+00, -3.5000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00],\n", + " [ 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 7.3712506e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, -5.4000001e+00,\n", + " -1.9712504e+00, 0.0000000e+00],\n", + " [ 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 1.7057173e+01, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 1.9592170e+00,\n", + " -1.2600000e+01, -6.4163899e+00],\n", + " [ 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 8.1257477e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 6.2742519e+00, -1.4400000e+01]], dtype=float32)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "mat, (load_bus, gen_bus, stor_bus, lor_bus, lex_bus) = obs.flow_bus_matrix(active_flow=True, as_csr_matrix=False)\n", "mat, (load_bus, gen_bus, stor_bus, lor_bus, lex_bus) = obs.flow_bus_matrix(active_flow=True, as_csr_matrix=False)\n", @@ -509,9 +810,28 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The load 5 absorbs: 28.50MW\n", + "It is connected to the bus id 8 of the matrix\n", + "And we can see the diagonal coefficient of the \"flow bus matrix\" at this bus is: -28.50\n", + "Also we can see that powerlines [10 11 19] have their origin side connected at this bus.\n", + "And powerlines [16] have their extremity side connected at this bus.\n", + "And, for example, if we look at powerline 10, that connects bus 8 to bus 9 we can see that:\n", + "The flow from bus 8 to 9 is -4.38MW\n", + "For information, the flow at the origin side of this line 10 is 4.38MW. And this is not a coincidence.\n", + "\n", + "Also, we want to emphasize that this matrix is NOT symmetrical, for example:\n", + "\t the power from bus 8 to 9 is -4.38498 MW\n", + "\t the power from bus 9 to 8 is 4.37878 MW\n" + ] + } + ], "source": [ "load_id = 5\n", "this_load_bus = load_bus[load_id]\n", @@ -613,11 +933,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "import networkx\n", "graph = obs.as_networkx()\n", @@ -633,9 +964,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAADnCAYAAAC9roUQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAtE0lEQVR4nO3dd1RUZ7cG8OfMDDAUYUSqgIKgICpYMGILYG8JftGoUTRWTNQYY2KaaddoNNiNGntPIohRLNh7VCzYo4ggKChdR0SZPvcPxBZFmDkz58ywf2vddb8lcmaDL08O77xnb0ar1YIQQohxCLgugBBCqhMKXUIIMSIKXUIIMSIKXUIIMSIKXUIIMSJRRR90cnLSent7G6kUQggxD8nJyYVardb5VR+rMHS9vb1x9uxZw1RFCCFmimGYW6/7GG0vEEKIEVHoEkKIEVHoEkKIEVHoEkKIEVHoEkKIEVHoEkKIEVHoEkKIEVHoEkKIEVX4cER1VlgiR3xyNlJyi1EsU8FeLEKAmz3eb+GJWnZW1bYWQoh+mIqamIeEhGir2xNpF7OkWHQ4DUdSCwAAcpXm6cfEIgG0AML9nTEmzA/BXpJqUwshpPIYhknWarUhr/wYhe4zG5IyMS0xBTKVGhUN1GAYQCwSYnKPAESFept9LYSQqqkodGl74YmykLuGUqXmjX9XqwVKlWpMS7wGAKyHHZ9qIYSwi95IQ9mv8dMSUyoVcs8rVWowLTEFl7KlZlkLIYR9FLoAFh1Og0yl1ulzZSo1Fh9OM8taCCHsq/ahW1gix5HUggr3TSui1QKHrhegqERuVrUQQgyj2odufHK23tdgAMSf0/86fKqFEGIY1T50U3KLXziKpQuZSoOUnIdmVQshxDCq/emFYpmKlevs+icFZ+L263WNwtqegF0NvWsplin1vgYhxDCqfejai9n5FnRvF4C5/QfodY0Jseex9cJdvWvJyyrCgQP/wtfXFV5ejhAKq/0vNITwRrUP3QA3e1iJcvX6tV4sEiDAXf87VDZqsRQw8LSzwD/Hb2Dt2n9QWFQCb28n+Pm6wtfPBfX9XOHj4wxra0u96yWEVF21D92+LTwxd3+qXtfQAujb3JMXtTACBtNGtnvak+HxYzlu3ixAWloebqTmYteuS7h1qxAuLvbw83WFn58r/Pxc4OvrCkdHW72/BkJIxap96DrZWSGsgTP2XcvT6agWwwAR/s6sNJ4xRC02NlZo3NgTjRs/+4+CSqVGVtY93EjLQ3paHjbGnkJaWh4sLIRlIez7LIg9PGpCIGD0/toIIWWqfegCwNhwPxy7UYhSZdUfShCLhBgT7mdStYhEQvj4OMPHxxno3BgAoNVqkZ9fjLT0fKSn5eHgoWtYtvwwHjwoRb16zi9sT3h7O8HKyqLK9RFCqOHNU1Xpd1DO2kKAyT0actp7wdC1lJTIkJ6ej7S0vLL/S89HdvY9uLtLXghiX19XODhYs/rahJgqanhTCeVhVanOXgDEFobr7FWlWgzcZczOTozg4DoIDq7z9M8UChVu3y56uj1x8mQa0tPzYWNjCV/fJyH8ZJvC3d0BDEPbE4SUozvdl1zKlmLx4TQcul4ABmUPG5QTiwRQqjXwlggxd2AogjwlnNaiRdke7phwP4PX8iZarRY5OQ+Qll4WxDfS8pCeno/HjxXw9XWBn6/LkyB2gbe3MywshJzWS4ghUT9dHRSVyBF/LhspOQ9RLFPCXmyBAPcaCPOVIHp+LLZ+PxSONWyMXsveO+fRxaMZAtxroG9z/k+OePDgMdLT85/cFecjLT0POTlSeHo6Pg3isu0JF9jZibku95VocgepKgpdlk3beAA1rK0wPrKd0V+765EJ2BM2z+ivyya5XImMjMInd8VlQXzzZgEcHKxf2p5wgYuLPWfbEzS5g+iK9nRZNqxLS3ww4w8M6dgCEjt686iqrKwsEBDgjoAA96d/plZrcPeuFOnpeUhLy8f2beeRlp4HlVL9NIDL/3+dOrUgEhl2e+JNkzvKt3r2Xs3D0dRCmtxBKo1CVwe1He3Roakf/jh8HmN7teG6HLMgFArg5eUILy9HhIc3fPrn9+6VPN2eOJWUjj/+OIH8/GLUrev0wvZEvXrOsLFh51d9mtxBDIlCV0cjurRE1My/MLhDc9jb8HMv0hw4OtrB0dEOLVvWe/pnpaWKsqfsnmxP7N17BbduFaJWLbv/bE/UqmVXpe0JfSd3BHlKOH9Tk/Abha6OPJ0keLtxPfx15AJGdw/lupxqxdraEo0aeaBRI4+nf6ZWa5CVdQ/p6WUnJzbHn8GNtDwIBMyTp+yebU94er6+CRAbkzuWRL1yK48QABS6ehnR9S0MnROLQeHNYGdN72JzSSgUwNvbCd7eTujYsRGAsmNshYUlTx7qyMOxo9exevVR3Lv3CD4+zi9sT/j4OKNEpWFtcgedaiCvQ6Grh7ouNdGmYV1sPHoRI7u+xXU55CUMw8DZuQacnWugdetnj0eXlMiebk9cT8nBjh0XkJVVBLlPbajs7VH2+IuOr4myyR2j3/bV/wsgZolCV08ju7bC8Hlx+CCsKWzF1C7RFNjZiREU5IWgIK+nf6ZUqvHR2jO4mV6k17Vpcgd5E+purScfN0e81cALcccucl0K0YOFhRBalp6So8kdpCIUuiwY1a0VNhw8h1I5/bCZMramiNiLqQMbeT0KXRb41XZCM9/aiD9+metSiB7KJnfo9yPB1hQRYr4odFkyslsrrNt/FjIFO4MuifH1baH/9A+2pogQ80Why5IATxc08nbDlhN0t2uqyid36Nrqgc0pIsR8UeiyKLpbK6zefxZyJd3tmqqx4X4Q69jXge0pIsQ8UeiyKLCOKxp4OCMh6V+uSyE6CvaSYHKPAFhbVO1Ho2xyRwA9AkzeiEKXZdHdWmH13jNQ6vgoKeFeVKg3JvdoCGsL4Zu3GrRaiA00KomYJwpdlgX5uMPb1RHbT1/luhSih6hQb8RGh6JroCusRAKIXzrVIBYJYCUSwFugwQeOFhS4pNLoiTQDiO7eCt+t2413WgXCQkhjaUx18kKQpwRLokJeO0Wkb3NPCJQqRA9ZjhvdG6G+v/ubL0qqPQpdA2jm6wGPWg5IPJOCyNBGXJfDmYonL+Ri7v5Uk5i8UMvOqoJeClaIHtMBs2fsxMLlwwzeXJ2YPtpeMJDo7qFYsec0VOqq9WU1FxuSMjFgeRL2XcuDXKV5IXCBsh4FcpUGe6/mYcDyJGxIyuSmUBZ06tYEkpq2iN94iutSiAmg0DWQkPqecHGwxZ7k61yXYnTPJi9UPD4eeHHygqkGL8Mw+PSL7tj0VxKys+5xXQ7hOQpdAxrVrRWW7zkFtab63O3qO3nhUrbUMIUZmHttCQYOaYt5MYmoaNgrIRS6BtTKvw7sbcTYd+4G16UYDRuTF0xV774tIZcpsWv7Ba5LITxGoWtADMNgdPdQLN9zChqN+d/9FJbIWZu8YIqEQgEmft0Tq5YdRmEh9dQlr0aha2BtGtaF2FKEgxdN9w6usuKTs/W+RvnkBVPl4+uCXpHNsHDOHq5LITxFoWtgDMNgdLdQLNudZPZ3uym5xf85pVBV5jB5YeCH7XD7ViGOHU7huhTCQxS6RtC+sQ8EjABHrtzkuhSDKpax0+jH1CcvWFqKMPGrnlg0bw8eFpdyXQ7hGQpdI2AYBtHdW2HZriSzfmebJi880zjIC23a+2PZ4gNcl0J4hkLXSMKb+EKl1uDYvxlcl2IwbExesBIyZjN5YcRHEUg+nYHzyZlcl0J4hELXSAQCpuzc7u5TZnu3y8bkBYVChSsxm7Fn/VE8fmjav5rb2lph/OfdMC8mETIT3zIh7KHQNaJOTevjkUyBkym3uS7FIJzsrNDez0nnz2cYoHNjdwz8uBOSEi9gcODnmDV6OS4eS4HGRB8wCW1bHw0C3LF+1VGuSyE8QQ1vjKj8bnfprpNoHVAHjK5zYXjqZv493M5PhZCRQK3DzbxYJMS4DvUR5ClB657NIS0oxsHYk/j9yz8geyRHpw/aoNMHbeHm7cx+8QY0ZkIXRA9ZjrAOgWgQQJ3Iqju60zWyLs0bQFoiw5nULK5LYdWOCykYsiwOI8Oa4Kd3GrEyeUHibI/3xnXF7yemYPK6MSi+9wifRkzBV71+xf4/j0P2yDQeoqhZ0xbRYzpgzq87oaLm9tUeha6RCQUCjOr2FpbuMo+OVDKlCj9t2Y9F+09i+fD30O+tIAxuXfnJCwwDWFsIK5y8wDAM6jf1xpiZg7A+ZQ7eGdURR7ecQVTDiZgzdhWunEzl/T75005kf5nHvzvRHYUuB7q1CEC+9CGS00z3ySsAuFV4HwN/34iHpXJsGjcQDWu7PP1YZScvdA10RWx0aKUnL1haWaBdZAimbJqApaenwauBOxaMX4sRzb7GXzO3oyC7iM0vkTUMw2DCpO7YtJE6kVV3TEV3CCEhIdqzZ88asZzqY+vJK9h19jqWftKnSp/X9cgE7AmbZ5iiqmD3peuYuu0QxnZsjQGhQRXuT1c0eYGNyRFarRapyRnY98c/OPL3adRv6o3Og9qizTstYGVtqff12Zx88XfcaRw/eh0zF0RBIDCvPX3yDMMwyVqtNuSVH6PQ5YZSrUbklDX45cPuaFqvdqU/j+vQlStViEk8iuOpmZg9sCcaebhyVsurKGRKnNx5Dns3/IPryRlo/78QdBnUHgEt61X5jcuKJ18IoAWqPPlCrdZgwkdr0a1XMHpGNq9SPcR0VBS6tL3AEQuhEMM7t8Ty3aazx3e7SIqoJbEofPgIceMG8i5wAcBSbIGwPq0wbcvn+P3kFLjWccKsj1YguuVkxM3diaKc+5W6jqEmX5R3Ilu9/Ah1IqumKHQ59G6rQKTnFOFyZi7XpbzR3is3MOj3jYhsHoh5g3rB3lrMdUlv5OzhiAGf98KK5F/w2aJhyMkowOhW3+P7PnNw9O/TULzmgQVDT77w8XVBr97NsXD2bt6/AUjYR6HLIUsLEYZ1bonlu5O4LuW1FCo1pm8/hFmJR7How96IatvM5M4XMwyDwFb18emCodiQMhsR/Vojcc0RRAVMxMKJ65F6LuNp+Blr8sXAIW1x+3YRdSKrhujhCI71bt0IK/eexrWsPDT04tev63fuP8DEP3fCxd4Omz4ZBAcTuLt9E7GNFTr0b40O/Vsj73Yh9v91AtOH/g5La0t0iWqHHdYOek++WBL1yq28F5R3Ivv5+7/RrIU3athb6/SaxPTQnS7HrCxEGNopBMt4dm734NV0DFj0F7oH+WNB1DtmEbgvc63jhEFfvYtVF3/FuDmDcS0lB4eNOPmicZAX2oX5Y9ki6kRWnVDo8sB7bZrgcmYOUu8UcF0KlGo1YnYewS/bD+G3we9iaPsWJredUFUMw6BJW3849Xsbllb6tZWs6uSLER9FIPlMBs6dNd/uc+RFFLo8ILYUYUjHEM5PMtyVFuPDpZuQWXAf8eMGoWndyh9lMwdcTL6wsbHCp19QJ7LqhEKXJ95vF4TktDtIyynk5PWPpNzEgEV/oWMjXywcEgmJbfXbY+Rq8kWrNvUREOiBdSupE1l1QKHLE9ZWFhjcoTlW7D5t1NdVqtWYvesYpmw9gLmDemFEWMtq+6QUl5MvPv60M/btvozrKXdZqYHwF4Uuj/RrH4xT128jI9c4z+bnPniIYcvjcT2nAJvGDUILbw+jvC5fsTH5QiwS6DT5omZNW0SP7Yg5M6gTmbmj0OURW7ElBoY3w8q9hr/bPXY9E/0W/om3/X2wZOj/4GhnY/DX5Ds2Jl9oAfRtrtt1OnVtDEdHO2z6i7/nton+KHR5ZkBYUxy/monbBVKDXF+l1mD+nuP48e99mP1BT0RHvFVttxNe5mRnhbAGzm9sR/laWi0kuYVIO3ZNpyfNGIbBp5O6I37jKWTf5me3NKI/Cl2eqWFthX7tg7HKAHe7+cUlGLlyMy5n5yJu3EC0rKf/nZ25GRvuB7FIqNPnWluKMK5Dfaz6KR6fdZqG84evVvkabu4SDPqwHebEJEKjoUeEzRGFLg8NimiGQxfTcafwAWvXPJl2C/0W/om3fL2wdNj/4FTDlrVrm5NgLwkm9wjQefLF4A9CsfjEFESO7ojfJqzFV71+xdVTaVW6VmSfECgVKiRuO1+lzyOmgUKXh+xtxHi/fRBW7Tuj97XUGg0W7T+Jb+L2YEb/bhjTMRRCAf2zVyQqVL/JF0KhABH9WmPZmWmI6NcaM4Yvwfd95yLt4q1KvX55J7I1K46gsKBYz6+G8A399PFUVERz7D9/Azn3dP+hK3j4CKNW/Y2zGXew6ZNBCPWtw2KF5o2NyRciCxG6DXkbK85NR0inJvjh/XmYOmQRbqXceePr+9RzwTv/a47f5uyhTmRmhpqY89j8hGN4JFMiumfbp5ML9t25iM4ewW+cXHAqPQtfx+3CeyGN6e5WT2xNvpA9lmP7sgOIX7AbIZ2aIOqbSLj7uLz27ysUKnw8fCWGDH8bYR0asjrBghgWTY4wUceu5yJ61VGoLezAMEylJhdoNFosO3wafyVdwC99u6Ftg7rcFE9e69GDx9iyeC+2LT2AtpEtMPDLd+Hs4fjKv/vv5Wx8OXUHXLs1w/GbZee32ZhgQQyLQtcElTXSTkGpsuKD8gwDiEVCTO4RgB6NXfBV3G4oVCrMHNADLvZ2RqqW6KK4qASb5idi15qj6DywLfpN7IGaLg4v/J0NSZn4KeFfqKBFWTudV3t+HVR2yCcxHApdE/NsckHlm69YiRjUEN1HVGhdjOvUBiIhbSeYiqJcKWJn78ShuJPoMTwcfcd3R42atjqtg7JTFK8fZ0+Mg0LXhFzMkmLA8qQ33uG+iqWQQfxHbRDkKWG/MGJwebcL8WfMNpzccR4tRnXGapkFZDp0PbO2ECI2OpTWAYdoMKUJWXQ4TefJBUqNFosPV+1MKOEP1zpO+GzhcMzdPxm7CxWQKXTrelY+wYLwE4UujxSWyHHEiJMLCD9ZudXEXTtbQMcTJ7QO+I1Cl0fikys/ceB1qjq5gPAPrQPzRqHLI1xMLiD8Q+vAvFHo8ghXkwsIv9A6MG8UujzC5eQCwh+0DswbhS6PcDm5gPAHrQPzRqHLI1xPLiD8wMY6kCvVED28j0elChYqImyi0OURfScXMAwQ4e9MzU9MHBvroJW3BGkZuYj8fAXm/HEYd/KlrNZIdMfO5hFhzdhwPxy7UajTE2likRBjwv0MUBUxNn3Xwbe9GiPIU4LcomJs2n8Bw6b8haD6tTGgSzO0CPACo/NMIqIvutPlGX0nF9Cjn+aBrXXgVssen/R/GwmzR6JNkA9mrjuIQd+vx7ajVyDX8Yk3oh/qvcBT5V3GZCp1hU+oUXcp88b2OtBqtTh15RY27j2HlMx8RIY1Qd+OwXCuSR3p2EQNb0zUpWwpFh9Ow6HrBWCAF5qflPdRjfB3xphwP7rDNWMVrQNLEQOFSoMugW4YF1G1dXAr5x7i9p3HnqQUtA7ywYDOzdDI1539L6AaotA1cc9PLnjwYA8cHLrqNLmAmLbXTbDYe+kMxnduhTB/H52u+/CRDNuOXkHc/gtwkthiQJfmiGjhB5GOU5H5MOGC6xoodM2IJrcBBG6pXJdBeGRj0kWczsjGnA966nUdtUaDo+fSEbvvPLLzpXi/Y1NEhjeBxM66Up9/MUuKRYfTcCS1AAA3Ey74UANAoWtWKHTJy6SPZeg6axX2ThoOB2sxK9dMvZWPjXvP48i5NHRs2QD9uzSDr6fTa/8+H96D4EMNz16D+ukSYrYkNmK09quD3ZfY+49xg7ou+GFUV8TNGAoXRzuMi9mMcTHxOHbhJjSaFxPt2YSLisMOKGs7WapUY1riNWxIymStXj7UUFkUuoSYgd7NA5Fw/irr163lYIuRvVtj25yR6Nk2EMu3nMT7X69G7N5zeFSqwMUs6ZNZflXrilaq1GBaYgouZUv1rpEPNVQFhS4hZqBt/brIuvcAmYX3DXJ9C5EQ3dsGYu1PA/HDyK64kHoXkZ+vwGfrkyDT4QEOgL0JF/pMW+FiygaFLiFmwEIoRK/gACScY/9u93kMwyC4gQemj+uFBV/3w60SNXQcdMLKhAtTnLZCoUuImYhsHohtF679Z8/VUI5mPNB76rS+Ey5MccoGhS4hZiLA3Rn21mKczsgyyuvxYcIFH2qoKmp4Q4gZ6d0sEAnnriLUt47BX4utCReJJ6/j5PaDOn3ufScPwFr/R5iNOWWDQpcQM9Iz2B+LDybhkVwBWytLg74WWxMuerT2x9z+/XX63Amx57H1wl29azDmlA3aXiDEjDjVsEUL79rY9+8Ng78WHyZc8KGGqqLQJcTMRDYLRMK5awZ/nb4tPHU+uVBO30knpjhthUKXEDMT0bAerucW4M79YoO+zoWsLAgFj3T+fDYmnZjitBUKXULMjKVIhG5NGmD7ecPc7eY/LMH42O2Yte8f/NAzCNYWunUjY2vSydhwP4h17IjGxbQVCl1CzFDkk8eCK2poVVVarRbxyVfQ+/cNqOfkiISPo/DBWw04n3RiatNW6PQCIWYoyNMNAobBhds5aFa3tt7Xu1UkxQ/b9+ORXIFVQ/ogwM356cfKO3Vx2eGLDzVUFoUuIWaIYRhENg/E1nNX9QpdlVqD1SeSsfLEWXzUvhUGhzaFUPDfO8qoUG8EeUo4nXTChxoqg/rpmoAXuuBL98Je0sXonfiJ6cl98BC9F6zH5nEfYvul3CpPUfj3bh6+37YfEhsxprzTCZ41HSr1uq+bcGHMSSdc10BNzE0UX7rgE9N0MUuKkWuP4n6pCEIBU+n1U6pQYuHhk9hy4SomdWmP3sGBNLK9iih0TRCfuuAT0/N0/Sgr7gL28vpJunkbP2zfj8a13fBt9zA42dkarWZzUlHo0p4uDz3rgv/mRh7Pd8EHQMFLdFo/UxOvIeHiNRQ+uoMfenZAhH89I1RaPdGRMZ4xtS74hF90XT8ypQbnbmswvXckBa6BUejyjKl1wSf8os/60WiBNSdusVwReRmFLo+YYhd8wh+0fkwDhS6PmGIXfMIftH5MA4Uuj5hiF3zCH7R+TAMvTi+8cPi/Coe3zYFarUFRwUPk5Uhx89Y9Vq65b/dldP+/OFauRUxHVquGgJuj3tcx5hSF6ojT0K348H8u5u5PNfnD/8+Hat5dKfLu3n/uf0tRmF8Me4kNXGtLUOrqDDb+STp3a4K5qwfrXzwxKaY4RaE64ix033T4v/yZ6b1X83A0tZC3h//Vag2K8ouRlyNF7pMgLQ/V/JwXQ9XVXQLX2hIENPZEWJcmcKstgbOrPSytyhb5kiPpmLs/Va9fEY3dBZ/wR4CbPSwFOVDoMQ2Y1o/hcRK6pnT4X61SP71TfTlU83KkKMovhkNN26eB6lpbgsAgL0R0awLX2hI4uzrA0rJy3+a+LTwxd3+qXvUauws+4Z5Wq8XpXedxee5OKJsFA0LdessCtH6Mweihq+/h/yBPCavdgdQqNQoLHj79dT8v5z7ych4YJFTfpLwL/r5reTod++GiCz7hjkqpwqGNxxE3MwECoQD9J0VCoRJjf0o+rR8eM3rosnH4f0nUKx9pfqVXherzd6z3Ch7CwbEsVN2ebAE0CjZMqFbG2HA/HLtRiFJl1b9HXHTBJ8ZXWlKKXSsOIn7udnjUd0f0zCEI6RIMhmFQK0uKf9KKaP3wmFFDl83D2+X/NVar1CjIL34uVF/89f9Vodq4aR107BEMV3cJnN3sYWHBi0McAJ51wa/s9ks5rrrgE+O5n/8ACb/two6lexEc0Rg/xn8B/5YvhiStH/4zatqwcXhbrdbgk+m74VFwD3l3pbhX+BASR7unv/q7ujnwOlQrw5S64BPDu5uei/jZ23E49jjC+rXB/BPT4OHn/tq/T+uH34yaRmwc3lZpAXUtOwyKLPv138nV9EK1Ml7ugq/RKqFUP3uDhC9d8InhpCanI25mAi4cvIKe0Z2x8uo81HSVVOpzTWWKQnVk1LQqlqlYuY6dkz2avmX+nZCCPCVYEhWCohI5ftw/C5rS9pArrDnpxE+MQ6vVInnfJcTGbMWd1Bz0+awXJi7/GDY1rKt8refXT/kUhT2bTqLr+61p/XDIqKFrL2bn5arb4e2atkK0bHQAg3y/gEhAPyTmSK1S48imk4ibmQC1Uo1+kyIR8UFbiFj4La6WnRVGv+0LAOj8wTTMjf9Y72sS3Rk1dAPc7GElyqXD/1X0QJEFW5ELBa4Zkj2WY/eqg9g8Zzuc6zhh2M8D8FaP5jQex4wZNXTp8L9upIpMSCx9uC6DsOhBYTG2LdqDbYt3o1G7AHzz5wQEhjbguixiBEYNXTr8rxupIgMSK2+uyyAsyM3MR/zs7Tj45zG0ey8Uc45OgZe/B9dlESMy+tv+dPi/6u7LM1DXrj3XZRA9pF3IQNzMBJzdcxE9RnbE8itzUcu9JtdlEQ4YPXR1PbwtUKsxOtSrWh5tkSoyEGw5hOsySBVptVpcOHQFsTEJyLxyG+992hOf/h4NW3sbrksjHOLkgKsuh7f716+JM7N3IKuJG7zquRinUB7QaFV4qLwLB8s6XJdCKkmtVuOfv08jNmYrZI/k6DcpEh0SvnraTY5Ub5w9VaDL4e19jlaYPHIVYtZFw81T/2bNpoBOLpgOeakce9ceQfzsbZC4ShD1fV+E9moBgYAGtJBnOH2U61WHt4tlytce/u/cuwXkjxX4ZvhKzFwfDSdXBw6rNw6pIoNOLvBc8b2H2P77XiQs3AX/t/wwac04NG4bwHVZhKd48fzs84e336TXwNaQlSrx7fCViFkXDUktOwNXx637cjq5wFf5twuwee5O7Ft3GK0jW2LmgR9RN9CL67IIz/EidKuq74i3IStV4NsRK/HrmlGoITHfNyakikw6ucAzGVduI25mAk7tSEbXYR2w9OJsOHvW4rosYiJMMnQBYNDYjih9rMD3o1fjl1UjYWNrnnuedHKBH7RaLS4fu4bYmK1IO5eB3p/0wNj5w2EnseW6NGJiTHaHn2EYjJzUHb4NPfDjR2shK1VwXRLr1FolnVzgmEajwT9bTmF8m8mYM2oJ2rzbEutvLsIH3/yPApfoxGRDFygL3rE/vAvX2hJMHb8BCgU7Xcz4ophOLnBGIVMgccUBjAicgNhft6LfpEisvDoXPaM7w1JsyXV5xISZdOgCgEAgwGfT+kBsY4UZE/+CSocn3fiKei4YX4n0ETbO2ILBvuPwz5ZTmLB0NBac/AXt32sFoR4DHwkpZ/KhCwBCkRBfzewPpUKF2d9uglqtX6N0vqCTC8ZTeKcIyyatwxC/cci8moXpuybjl53fIjisEXX8Iqwyi9AFAAtLEb5bEIV7+Q+x8P+2QqvrIDYekSoyUJPudA3q1rVszBq+GNFBn0OlVOP35Bh8vW486gXV5bo0YqbMJnQBwEpsgR8XD0Fmai6Wzdhp8sErVWRCYkWhawhXjqfgh96/4ouIn+BezxVrUn/DmHnD4FrXmevSiJkzq9AFABtbK/y8bBgunbmJ9Qv2cV2Ozp6eXLCgkwts0Wg0OLHtDCa0/w4xHy5Ey65NsSFjEQZ91wf2tapXY3zCHZM9p1sRO3trTFsxHF8OWQ6xjSX6jQrnuqQqo5ML7FEqlDjwxz/YNCsBVtaW6P9lb7R7rxWEInpjjBifWYYuAEgc7TB91QhMGrwUYhtLvDuoDdclVcl96rmgt0fFj5G4bD/+nr8TdQI9MXbBCDTr0JjeGCOcMtvQBYBaLvaYvmokvhy8DFZiS3TtE8J1SZUmlWeiJu3n6uRe7n1smZ+IxBUH0KJLEH7e9jX8mtH3kvCDWYcuALh61MS0lcPx9dAVsBJbILxnMNclVYpUkYG6dm9zXYZJyU69i02ztuHY5iR0GNgeC09Ph7uPK9dlEfICsw9dAPD0ccbPy4dh8oiVEFtbILRDINclvZFUkYlgqw+5LsMkXDt1A3EzE3Dl2DW883FXrEqZD4mz+bf9JKapWoQuAPg0cMNPv3+IH0avwVdiSzRrw99Za3Ry4c20Wi1O7zqPuJkJyMssQN+J7+DLteNgbSvmujRCKlRtQhcAGjT2xHcLojB1/AZ8tyAKjVt4c13SK5WdXHClkwuvoFKqcGjjccTNTIBAKED/SZF4+/3WEFlUq6VMTFi1W6mNW3jjy5j+mDp+A6YsHYoGjT25Luk/yk4ueHNdBq+UlpRi14qDiJ+7HR5+boieOQQhXYLpJAIxOdUudAGgedv6mDC1D376eC2mrRwBnwZuXJf0Ajq58Mz9/AdI+G0Xdizdi6DwRvgx/gv4t+Tv1hAhb1ItQxcAQiMaQv7NO/h+1GrMWDMSnj78efyz7ORCGNdlcOpuei7iZ2/HoY3HEdavDeafmAYPP3euyyJEb9U2dAEgrEcQZKUKTB6xCjHro+HqUZPrkgCUnVxoajWU6zI4kZqcjriZCTh/4Ap6je6MVdfmoaarhOuyCGFNtQ5dAOjaJwSyUgW+HrYCszaMRi0Xe07rKT+5YG9RfQYcarVaJO+7hLiZCci+fhd9PuuFics/hk0Na65LI4R11T50ASAyqg3kpWWj3WPWjYLEkbsJw9Xp5IJapcaRTScRNzMBaqUa/SZFInxAG1hYWnBdGiEGQ6H7RL9R4ZA9VmDyyFX4dc0o2Nlzc5d1X5Fh9m+iyR7LsXvVQWyesx3OXk4Y9vMAtOzeDAKB2TW9I+Q/KHSfM3h857IJw9GrMW3lCE4mDEvl5jui50FhMbYt2oNti3ejUbsAfPPHpwhs7c91WYQYFd1aPIdhGER/3RPe9d3wf2PWQS5TGr0GqRme0c3NzMei8aswzH88CrKLMOfoFPy0eRIFLqmWKHRfwjAMxv3UG44uNTB1/AYojTxh2Jy2F9IuZOCXQfMwJuQrWNlYYtnlOZi4/CN4+XtwXRohnKHQfQWhUIAvpr8PSysL/DopFmqVcSYMqzUKlChzTLrnglarxfmDl/F1t6n4rtd0+DX1wfr0hRg5IwpOtR25Lo8QzlHovoZQJMRXswdA9liOuZM3Q6Mx/IThYmU27ERuEAosDf5abFOry04ijGv1DX4btxLh/dpgXfoi9JsUCVsHW67LI4Q3KHQrYPlkwnDeXSkWTUkw+KDL+wrTG7kuL5Vj+5K9GB7wKf6etwODJvfBiitz0G14B1ha0dEvQl5GofsGYmtL/N+SD5F+7S5WxCQaNHilctMZ0VN87yH+mLYZg+uNxeld5zBp9VjMPz4NbSJb0tEvQipAPx2VUDZheDguJKXjj0UHDPY69xUZqMnz0M3PKsSSiWswtP4nuJuei5j9P+LnhK/RuF1DrksjxCTQOd1KquFQNmF40uBlEFtbou8I9kfpSBWZvN1eyLhyG5tmbUPSjmR0HRqBpRdnw9mzFtdlEWJyKHSrQFLLDtNXj8CkqKUQW1ug18DWrF2bjycXtFotLh+7htiYrUg7l4Hen/TAx3OHokZN7h6TJsTUUehWkZOrA6avHokvhyyDlY0lOvduwcp1HyizeHNyQaPR4ETCGcTGJKC46CH6ffEufoz/ApZi7msjxNRR6OrAzdMRv6wcga8+XA6x2BLtuzXR+5plWwvc7ucq5ErsX38Um2YlwNbBBv2/7I02vVtCKBRyWhch5oRCV0eePs6YunwYvh2xCpZWIrSK0O+NpLKTC97sFFdFJdJH2LF0H7YsSIRvU29MWDIaQWGBNAqHEAOg0wt68PF3x0+Lh2Dud5tx/mSaXtfi4uRC4Z0iLJu0DkP8xiHz39uYvmsyftn5LYLDG1HgEmIgFLp68g/ywuR5gzDj843491ymzteRyjOMtr1w61o2Zg1fjOigz6FSqvF7cgy+Xjce9YLqGuX1CanOaHuBBU1a+uDLmH74+ZMNmLpsGPwaVa2hi1qjQIkqFw4Gnhbx74nriI3ZimtJNxA5thvWpP4G+1o1DPqahJAXUeiypEW7Bhj/f//DDx+twS8rR8C7ChOGDXlyQaPR4NTOc4iN2Yqiu/fx/ufv4ts/J0BsY/6TKQjhIwpdFrXp1AhymRLfjVqNX9eOgoe3U6U+zxBbC0qFEgf++AebZiXAUmyJ/l9Gon2fUAhFdBKBEC5R6LIsoldTyEuV+HbESsSsq9yEYTbfRHtU/BiJy/bj7/k7USfQE2PnD0ezjk3ojTFCeIJC1wC6vd8SslIFvh2+EjPXR8PxDROGpYpM+NTooNdr3su9jy3zE5G44gCadw7ClISvUL95Pb2uSQhhH4WugfQe0hay8gnD66PhUPNZT9nCEjnik7ORkluMYpkKUpU72nnXwIet5KhlV7W91uzUu9g0axuOxiehw8B2WHhqOtzrubL95RAT9vx6u9OnAybEnkeAmz3eb+FZ5fVG9MdU1KowJCREe/bsWSOWY37WzN2Ds8dSMWPNSKQ/kGPR4TQcSS0AAMhVzxqji0UCaAGE+ztjTJgfgr0kFV435fQNxMYk4PLRq3jn466IHNcNEmcHA34lxNRczJKytt5I1TAMk6zVakNe+TEKXcPSarVY8st27Ln1ACmuTpCrNaioJS/DAGKREJN7BCAq1Ps/1zqz+wJiY7YiNyMffSe+g24jOsDaVmzYL4KYnA1JmZiWmAKZSq3zeiO6qyh0aXvBwBiGgW2HJriy7V+oVG8e+aPVAqVKNaYlXgMARIV6Q6VU4dDG49g0axsYhkG/SZEI69caIgv65yP/VRa411Cq1G29EcOin1oDu5glxfRd16FC1U4PlCo1mLrzGoqO/YtTC7fDw88No36NQkjXpnQSgbzWxSwppiWmVCpwn1eq1GBaYgqCPCUI8pQYpjgCgELX4BYdToNMx2nCMoUKf98uwbL4L+Df0o/lyog50mu9qdRYfDgNS6Je+VsxYQn1XjCgwhI5jqQWVLinViGBALkSCZwaGvbxYGIe9F1vWi1w6HoBikrk7BZGXkCha0Dxydl6X4MBEH9O/+sQ80frzTRQ6BpQSm7xC8d0dCFTaZCS85Cliog5o/VmGmhP14CKZSpWrrMnPgmdB05n5VrEfN15LwLw038rqlimZKEa8joUugZkL2bn29u1byjmbvqIlWsR8zUh9jy2Xrir93XsxRYsVENeh7YXDCjAzR5WIv2+xWKRAAHu1POWvBmtN9NAoWtAfVt46n0NLYC+zfW/DjF/tN5MA4WuATnZWSGsgTN0fZaBYYAIf2dqSkIqhdabaaDQNbCx4X4Q69g4XCwSYkw4PRRBKo/WG/9R6BpYsJcEk3sEwNqiat9qawsBJvcIoEcySZXQeuM/Or1gBOVNRKjrEzEGWm/8RqFrJFGh3gjylGDx4TQcul4ABmUH0cuV9zeN8HfGmHA/uuMgeqH1xl/UT5cDRSVyxJ/LRkrOQxTLlLAXWyDAvQb6NqdO/oR9tN6Mj5qYE0KIEVUUuvRGGiGEGBGFLiGEGBGFLiGEGBGFLiGEGBGFLiGEGBGFLiGEGBGFLiGEGBGFLiGEGFGFD0cwDFMA4JbxyiGEELNQV6vVOr/qAxWGLiGEEHbR9gIhhBgRhS4hhBgRhS4hhBgRhS4hhBgRhS4hhBjR/wOVbw1Twhc5TwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "networkx.draw_networkx(graph,\n", " with_labels=False,\n", @@ -649,7 +991,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -695,9 +1037,136 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 2.0190000e+03, 1.0000000e+00, 6.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 6.0000000e+00, 8.1400002e+01, 7.9300003e+01,\n", + " 5.3000002e+00, 0.0000000e+00, 0.0000000e+00, 8.2246674e+01,\n", + " 1.9496038e+01, 7.1340233e+01, 2.4368923e+01, 2.4368923e+01,\n", + " 2.4018070e+01, -1.7274660e+01, 1.4210001e+02, 1.4210001e+02,\n", + " 2.2000000e+01, 2.2000000e+01, 1.3200001e+01, 1.4210001e+02,\n", + " 2.1900000e+01, 8.5800003e+01, 4.4299999e+01, 6.9000001e+00,\n", + " 1.1900000e+01, 2.8500000e+01, 8.8000002e+00, 3.5000000e+00,\n", + " 5.4000001e+00, 1.2600000e+01, 1.4400000e+01, 1.5400000e+01,\n", + " 5.9700001e+01, 3.0799999e+01, 4.8000002e+00, 8.3000002e+00,\n", + " 1.9400000e+01, 6.0999999e+00, 2.4000001e+00, 3.9000001e+00,\n", + " 8.8000002e+00, 1.0500000e+01, 1.4210001e+02, 1.4210001e+02,\n", + " 1.3866075e+02, 1.3929695e+02, 2.2000000e+01, 2.1130220e+01,\n", + " 2.1129551e+01, 2.1478817e+01, 2.1571596e+01, 2.1432823e+01,\n", + " 2.0750198e+01, 4.2346096e+01, 3.9900578e+01, 2.3991766e+01,\n", + " 4.1828262e+01, 3.5666172e+01, 1.7225140e+01, -2.7542929e+01,\n", + " 8.1183472e+00, 7.4602180e+00, 1.7347816e+01, 4.3849845e+00,\n", + " 8.2175179e+00, -4.4212246e+00, 1.9712504e+00, 6.4163899e+00,\n", + " 2.6171078e+01, 1.4931423e+01, 3.9526379e+01, -1.0408341e-14,\n", + " -2.6171078e+01, -1.6060501e+01, -1.2141596e+00, -7.4234338e+00,\n", + " 4.0774456e-01, -4.4919857e-01, 7.7376227e+00, -2.1186779e+00,\n", + " 1.0543067e+01, 5.6506634e+00, 1.5188450e+01, -1.5994288e+00,\n", + " 3.6139119e+00, -7.7159214e+00, 1.5654972e+00, 7.3706942e+00,\n", + " -1.6119450e+01, -3.0833588e+00, -5.6308179e+00, -2.3178274e+01,\n", + " -4.4921541e+00, 1.4210001e+02, 1.4210001e+02, 1.4210001e+02,\n", + " 1.4210001e+02, 1.4210001e+02, 1.4210001e+02, 1.3866075e+02,\n", + " 2.2000000e+01, 2.2000000e+01, 2.2000000e+01, 2.1130220e+01,\n", + " 2.1130220e+01, 2.1129551e+01, 2.1571596e+01, 2.1432823e+01,\n", + " 1.3866075e+02, 1.3866075e+02, 1.3929695e+02, 1.4861537e+01,\n", + " 2.1130220e+01, 1.8401025e+02, 1.6219051e+02, 1.0203776e+02,\n", + " 1.6995570e+02, 1.4492264e+02, 7.6722275e+01, 1.1502098e+02,\n", + " 3.4920593e+02, 2.4560159e+02, 6.0509528e+02, 1.2753420e+02,\n", + " 2.4528467e+02, 2.4299077e+02, 6.7372948e+01, 2.6324207e+02,\n", + " 1.2798145e+02, 6.3482616e+01, 1.6548074e+02, 9.0044409e+02,\n", + " 7.2554138e+02, -4.1986198e+01, -3.9088322e+01, -2.3725140e+01,\n", + " -4.0866714e+01, -3.4981895e+01, -1.6992859e+01, 2.7643835e+01,\n", + " -7.9793596e+00, -7.3712506e+00, -1.7057173e+01, -4.3787756e+00,\n", + " -8.1257477e+00, 4.4793596e+00, -1.9592170e+00, -6.2742519e+00,\n", + " -2.6171078e+01, -1.4931423e+01, -3.9526379e+01, 1.0408341e-14,\n", + " 2.6171078e+01, 1.1560926e+01, -5.4758495e-01, 3.9026122e+00,\n", + " -1.0090021e+00, -1.0585623e+00, -8.4695101e+00, 2.4369648e+00,\n", + " -1.0252009e+01, -5.4654975e+00, -1.4616084e+01, 1.6159215e+00,\n", + " -3.4187043e+00, 7.8520093e+00, -1.5546099e+00, -7.0812955e+00,\n", + " 1.7991196e+01, 4.2857671e+00, 9.0556650e+00, 2.4018070e+01,\n", + " 5.1870790e+00, 1.4210001e+02, 1.3929695e+02, 1.4210001e+02,\n", + " 1.3866075e+02, 1.3929695e+02, 1.3866075e+02, 1.3929695e+02,\n", + " 2.1478817e+01, 2.1571596e+01, 2.1432823e+01, 2.1129551e+01,\n", + " 2.0750198e+01, 2.1478817e+01, 2.1432823e+01, 2.0750198e+01,\n", + " 1.4861537e+01, 2.1130220e+01, 2.2000000e+01, 1.3200001e+01,\n", + " 1.4861537e+01, 1.7693805e+02, 1.6202699e+02, 9.7690315e+01,\n", + " 1.7021111e+02, 1.4505737e+02, 7.9055550e+01, 1.1502098e+02,\n", + " 3.4920593e+02, 2.4560159e+02, 6.0509528e+02, 1.2753420e+02,\n", + " 2.4528467e+02, 2.4299077e+02, 6.7372948e+01, 2.6324207e+02,\n", + " 1.2337778e+03, 4.2445111e+02, 1.0641736e+03, 1.0505181e+03,\n", + " 1.0364877e+03, 3.4012985e-01, 3.6042336e-01, 2.7210069e-01,\n", + " 2.6722595e-01, 8.2812935e-01, 2.6920095e-01, 3.4334621e-01,\n", + " 5.3151590e-01, 4.9516451e-01, 7.3167509e-01, 2.8853893e-01,\n", + " 3.8265938e-01, 2.8927472e-01, 4.3187788e-01, 3.9644888e-01,\n", + " 5.4460192e-01, 5.3346735e-01, 9.2447340e-01, 4.5339581e-01,\n", + " 4.6154031e-01, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " -1.0000000e+00, -1.0000000e+00, -1.0000000e+00, -1.0000000e+00,\n", + " -1.0000000e+00, -1.0000000e+00, -1.0000000e+00, -1.0000000e+00,\n", + " -1.0000000e+00, -1.0000000e+00, -1.0000000e+00, -1.0000000e+00,\n", + " -1.0000000e+00, -1.0000000e+00, -1.0000000e+00, -1.0000000e+00,\n", + " -1.0000000e+00, -1.0000000e+00, -1.0000000e+00, -1.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 5.3000002e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 1.0000000e+00, 1.0000000e+00, 1.0000000e+00, 1.0000000e+00,\n", + " 0.0000000e+00, -1.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, -2.1208096e+01, 2.1130220e+01, 1.0000000e+00,\n", + " 0.0000000e+00, 5.7500000e+02, 5.0000000e+00, 5.0000000e+00,\n", + " 1.0000000e+01, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 1.5000000e+01, 5.0000000e+00, 1.0000000e+01, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 1.5000000e+01], dtype=float32)" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "vector_representation_of_observation = obs.to_vect()\n", "vector_representation_of_observation" @@ -712,7 +1181,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -728,9 +1197,17 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[nan nan nan nan nan nan]\n" + ] + } + ], "source": [ "obs2.reset()\n", "print(obs2.gen_p)" @@ -745,9 +1222,21 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([81.4 , 79.3 , 5.3 , 0. , 0. , 82.24667],\n", + " dtype=float32)" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "obs2.from_vect(vector_representation_of_observation)\n", "obs2.gen_p" @@ -762,9 +1251,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "obs == obs2" ] @@ -808,7 +1308,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -818,18 +1318,42 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([81.4 , 79.3 , 5.3 , 0. , 0. , 82.24667],\n", + " dtype=float32)" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "obs.gen_p" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([82.7 , 80.9 , 5.3 , 0. , 0. , 80.43334],\n", + " dtype=float32)" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "obs_sim.gen_p" ] @@ -849,9 +1373,26 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 1., 1., ..., 0., 0., 0.],\n", + " [1., 1., 1., ..., 0., 0., 0.],\n", + " [1., 1., 1., ..., 0., 0., 0.],\n", + " ...,\n", + " [0., 0., 0., ..., 1., 1., 1.],\n", + " [0., 0., 0., ..., 1., 1., 1.],\n", + " [0., 0., 0., ..., 1., 1., 1.]], dtype=float32)" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "action_description = {}\n", "act = env.action_space(action_description)\n", @@ -901,7 +1442,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -960,9 +1501,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The results for DoNothing agent are:\n", + "\tFor chronics with id 0000\n", + "\t\t - cumulative reward: 645.702087\n", + "\t\t - number of time steps completed: 10 / 10\n" + ] + } + ], "source": [ "from grid2op.Runner import Runner\n", "from grid2op.Agent import DoNothingAgent\n", @@ -985,9 +1537,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The results for the custom agent are:\n", + "\tFor chronics with id 0000\n", + "\t\t - cumulative reward: 645.705750\n", + "\t\t - number of time steps completed: 10 / 10\n" + ] + } + ], "source": [ "runner = Runner(**env.get_params_for_runner(),\n", " agentClass=MyAgent\n", @@ -1019,9 +1582,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The results for the PowerLineSwitch agent are:\n", + "\tFor chronics with id 0000\n", + "\t\t - cumulative reward: 645.705750\n", + "\t\t - number of time steps completed: 10 / 10\n" + ] + } + ], "source": [ "from grid2op.Agent import PowerLineSwitch\n", "runner = Runner(**env.get_params_for_runner(),\n", @@ -1060,7 +1634,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.12" + "version": "3.8.10" } }, "nbformat": 4, From d51be7ad73889dd8b247c3b865ff2e69de69ef80 Mon Sep 17 00:00:00 2001 From: DONNOT Benjamin Date: Fri, 15 Sep 2023 09:31:09 +0200 Subject: [PATCH 07/18] making the tests using python 3.10 --- .circleci/config.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index f393378bc..a4ce2ab87 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -3,7 +3,7 @@ version: 2.1 executors: grid2op-executor: docker: - - image: bdonnot/grid2op:test + - image: python:3.10-buster working_directory: /Grid2Op python37: From 74d43ba45a8fe11de602ad41f9c99de41b75f18a Mon Sep 17 00:00:00 2001 From: DONNOT Benjamin Date: Fri, 15 Sep 2023 09:45:24 +0200 Subject: [PATCH 08/18] making the tests using python 3.10 --- .circleci/config.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.circleci/config.yml b/.circleci/config.yml index a4ce2ab87..a5618f363 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -29,6 +29,7 @@ jobs: parallelism: 4 steps: - checkout + - run: apt-get update -y - run: apt-get install -y coinor-cbc - run: python -m pip install virtualenv - run: python -m virtualenv venv_test From d504c6800685c3ced60d5ecb70db2a4679af175e Mon Sep 17 00:00:00 2001 From: DONNOT Benjamin Date: Fri, 15 Sep 2023 10:15:53 +0200 Subject: [PATCH 09/18] trying a fix for rte-france#523 --- .../Action/{_BackendAction.py => _BackendAction/__init__.py} | 4 ++-- grid2op/Action/__init__.py | 2 ++ 2 files changed, 4 insertions(+), 2 deletions(-) rename grid2op/Action/{_BackendAction.py => _BackendAction/__init__.py} (75%) diff --git a/grid2op/Action/_BackendAction.py b/grid2op/Action/_BackendAction/__init__.py similarity index 75% rename from grid2op/Action/_BackendAction.py rename to grid2op/Action/_BackendAction/__init__.py index 97de586fb..d34e00287 100644 --- a/grid2op/Action/_BackendAction.py +++ b/grid2op/Action/_BackendAction/__init__.py @@ -7,7 +7,7 @@ # This file is part of Grid2Op, Grid2Op a testbed platform to model sequential decision making in power systems. """ -This file is here to maintain compatibility with lightsim2grid (but will disappear "soon") +This folder / file is here to maintain compatibility with lightsim2grid (but is likely to disappear "soon") """ -from grid2op.Action._backendAction import _BackendAction +from .._backendAction import _BackendAction \ No newline at end of file diff --git a/grid2op/Action/__init__.py b/grid2op/Action/__init__.py index d082e05e8..03b116beb 100644 --- a/grid2op/Action/__init__.py +++ b/grid2op/Action/__init__.py @@ -20,6 +20,7 @@ "TopologyChangeAction", "TopologyChangeAndDispatchAction", "DispatchAction", + "_BackendAction" ] # Internals @@ -49,3 +50,4 @@ TopologyChangeAndDispatchAction, ) from grid2op.Action.dispatchAction import DispatchAction +import grid2op.Action._backendAction as _BackendAction From b7c2f6164533373815827970fb4e7684405a78a9 Mon Sep 17 00:00:00 2001 From: DONNOT Benjamin Date: Fri, 15 Sep 2023 10:21:15 +0200 Subject: [PATCH 10/18] add more tests for notebooks, fix a bug in certain pandas version when disconnecting elements --- getting_started/04_TrainingAnAgent.ipynb | 11 +- getting_started/05_StudyYourAgent.ipynb | 2926 ++++++++++++++++- grid2op/Backend/pandaPowerBackend.py | 4 +- .../tests/test_notebooks_getting_started.py | 263 ++ 4 files changed, 3168 insertions(+), 36 deletions(-) create mode 100644 grid2op/tests/test_notebooks_getting_started.py diff --git a/getting_started/04_TrainingAnAgent.ipynb b/getting_started/04_TrainingAnAgent.ipynb index ccc01c439..5627f35a2 100644 --- a/getting_started/04_TrainingAnAgent.ipynb +++ b/getting_started/04_TrainingAnAgent.ipynb @@ -202,8 +202,8 @@ "source": [ "from grid2op.gym_compat import GymEnv\n", "import grid2op\n", - "from gym import Env\n", - "from gym.utils.env_checker import check_env\n", + "from gymnasium import Env\n", + "from gymnasium.utils.env_checker import check_env\n", "try:\n", " from lightsim2grid import LightSimBackend\n", " bk_cls = LightSimBackend\n", @@ -329,7 +329,7 @@ "metadata": {}, "outputs": [], "source": [ - "obs, reward, done, info = gym_env.step(0) # perform action labeled 0\n", + "obs, reward, terminated, truncated, info = gym_env.step(0) # perform action labeled 0\n", "obs" ] }, @@ -339,7 +339,7 @@ "metadata": {}, "outputs": [], "source": [ - "obs, reward, done, info = gym_env.step(53) # perform action labeled 53\n", + "obs, reward, terminated, truncated, info = gym_env.step(53) # perform action labeled 53\n", "obs" ] }, @@ -528,7 +528,6 @@ "metadata": {}, "outputs": [], "source": [ - "from l2rpn_baselines.DuelQSimple import evaluate\n", "import shutil\n", "from tqdm.notebook import tqdm\n", "from grid2op.Runner import Runner\n", @@ -721,7 +720,7 @@ " if not act_as_vect in actions_count:\n", " actions_count[act_as_vect] = 0\n", " actions_count[act_as_vect] += 1\n", - "print(\"The agent did {} different valid actions:\\n\".format(len(actions_count)))" + "print(\"The agent did {} different valid actions.\".format(len(actions_count)))" ] }, { diff --git a/getting_started/05_StudyYourAgent.ipynb b/getting_started/05_StudyYourAgent.ipynb index 0e9d142a4..b9ea50105 100644 --- a/getting_started/05_StudyYourAgent.ipynb +++ b/getting_started/05_StudyYourAgent.ipynb @@ -44,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -60,9 +60,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/donnotben/Documents/grid2op_dev/getting_started/grid2op/Backend/pandaPowerBackend.py:30: UserWarning: Numba cannot be loaded. You will gain possibly massive speed if installing it by \n", + "\t/usr/bin/python3 -m pip install numba\n", + "\n", + " warnings.warn(\n" + ] + } + ], "source": [ "import os\n", "import sys\n", @@ -89,9 +100,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/donnotben/Documents/grid2op_dev/getting_started/grid2op/MakeEnv/Make.py:420: UserWarning: You are using a development environment. This environment is not intended for training agents. It might not be up to date and its primary use if for tests (hence the \"test=True\" you passed as argument). Use at your own risk.\n", + " warnings.warn(_MAKE_DEV_ENV_WARN)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The results for the evaluated agent are:\n", + "\tFor chronics with id 0000\n", + "\t\t - cumulative reward: 486.856873\n", + "\t\t - number of time steps completed: 30 / 30\n", + "\tFor chronics with id 0001\n", + "\t\t - cumulative reward: 462.282471\n", + "\t\t - number of time steps completed: 30 / 30\n" + ] + } + ], "source": [ "try:\n", " from lightsim2grid import LightSimBackend\n", @@ -144,9 +177,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "['0000',\n", + " 'dict_observation_space.json',\n", + " 'dict_attack_space.json',\n", + " 'dict_action_space.json',\n", + " '0001',\n", + " 'dict_env_modification_space.json']" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "os.listdir(path_agent)" ] @@ -160,9 +209,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[('/home/donnotben/Documents/grid2op_dev/getting_started/study_agent_getting_started/PowerLineSwitch',\n", + " '0000'),\n", + " ('/home/donnotben/Documents/grid2op_dev/getting_started/study_agent_getting_started/PowerLineSwitch',\n", + " '0001')]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from grid2op.Episode import EpisodeData\n", "episode_studied = EpisodeData.list_episode(path_agent)\n", @@ -171,7 +234,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -180,9 +243,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "datetime.datetime(2019, 1, 6, 0, 0)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from datetime import datetime, timedelta\n", "episode_data = this_episode\n", @@ -196,9 +270,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "next(this_episode.observations).minute_of_hour" ] @@ -219,9 +304,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total lines set to connected : 0\n", + "Total lines set to disconnected : 0\n", + "Total lines changed: 4\n" + ] + } + ], "source": [ "line_disc = 0\n", "line_reco = 0\n", @@ -247,9 +342,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total actions on powerline 14 : 1\n" + ] + } + ], "source": [ "id_line_inspected = 13\n", "actions_on_line_14 = 0\n", @@ -277,9 +380,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total hazards : 0\n", + "Total maintenances : 0\n" + ] + } + ], "source": [ "nb_hazards = 0\n", "nb_maintenance = 0\n", @@ -309,9 +421,924 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "type": "scatter", + "x": [ + 0, + 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 + ], + "y": [ + 87, + 89, + 88.0999984741211, + 87.5, + 88.19999694824219, + 87.80000305175781, + 88.0999984741211, + 87.5999984741211, + 87, + 85.5999984741211, + 86.4000015258789, + 84.9000015258789, + 84.30000305175781, + 84.19999694824219, + 82.80000305175781, + 85.80000305175781, + 85, + 86.5999984741211, + 84.5, + 85.80000305175781, + 85.69999694824219, + 84.19999694824219, + 84.0999984741211, + 84.9000015258789, + 83.5999984741211, + 84.19999694824219, + 82.19999694824219, + 84.30000305175781, + 84.69999694824219, + 83.5999984741211, + 85 + ] + } + ], + "layout": { + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "heatmapgl": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmapgl" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "title": { + "text": "Consumption of load 1" + }, + "xaxis": { + "title": { + "text": "Time step" + } + }, + "yaxis": { + "title": { + "text": "Load (MW)" + } + } + } + } + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import plotly.graph_objects as go\n", "load_id = 1\n", @@ -341,9 +1368,924 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "type": "scatter", + "x": [ + 0, + 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 + ], + "y": [ + 36.400001525878906, + 36.599998474121094, + 35.599998474121094, + 35.400001525878906, + 34.400001525878906, + 33.70000076293945, + 33.599998474121094, + 32.79999923706055, + 32.70000076293945, + 31.799999237060547, + 31.399999618530273, + 30.600000381469727, + 29.600000381469727, + 29.299999237060547, + 28.899999618530273, + 28, + 28, + 27.200000762939453, + 26.399999618530273, + 26.399999618530273, + 25.600000381469727, + 24.799999237060547, + 24.5, + 24.299999237060547, + 23.5, + 23.299999237060547, + 22.799999237060547, + 22.600000381469727, + 22, + 21.200000762939453, + 21 + ] + } + ], + "layout": { + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "heatmapgl": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmapgl" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "title": { + "text": "Production of generator 2" + }, + "xaxis": { + "title": { + "text": "Time step" + } + }, + "yaxis": { + "title": { + "text": "Production (MW)" + } + } + } + } + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "gen_id = 2\n", "# extract the data\n", @@ -372,9 +2314,924 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "config": { + "plotlyServerURL": "https://plot.ly" + }, + "data": [ + { + "type": "scatter", + "x": [ + 0, + 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 + ], + "y": [ + 137.96974182128906, + 72.48875427246094, + 69.81539916992188, + 72.50433349609375, + 72.38471984863281, + 71.48223114013672, + 70.87670135498047, + 68.60836029052734, + 67.214111328125, + 67.40162658691406, + 66.00444030761719, + 65.37370300292969, + 62.280765533447266, + 62.12760925292969, + 61.809505462646484, + 60.048377990722656, + 60.349159240722656, + 60.78220748901367, + 58.05248260498047, + 57.39665603637695, + 55.339229583740234, + 53.9398193359375, + 54.09462356567383, + 55.7864875793457, + 53.59382247924805, + 53.371826171875, + 52.07499313354492, + 53.45325469970703, + 52.256771087646484, + 50.28155517578125, + 50.90947341918945 + ] + } + ], + "layout": { + "template": { + "data": { + "bar": [ + { + "error_x": { + "color": "#2a3f5f" + }, + "error_y": { + "color": "#2a3f5f" + }, + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "bar" + } + ], + "barpolar": [ + { + "marker": { + "line": { + "color": "#E5ECF6", + "width": 0.5 + }, + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "barpolar" + } + ], + "carpet": [ + { + "aaxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "baxis": { + "endlinecolor": "#2a3f5f", + "gridcolor": "white", + "linecolor": "white", + "minorgridcolor": "white", + "startlinecolor": "#2a3f5f" + }, + "type": "carpet" + } + ], + "choropleth": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "choropleth" + } + ], + "contour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "contour" + } + ], + "contourcarpet": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "contourcarpet" + } + ], + "heatmap": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmap" + } + ], + "heatmapgl": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "heatmapgl" + } + ], + "histogram": [ + { + "marker": { + "pattern": { + "fillmode": "overlay", + "size": 10, + "solidity": 0.2 + } + }, + "type": "histogram" + } + ], + "histogram2d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2d" + } + ], + "histogram2dcontour": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "histogram2dcontour" + } + ], + "mesh3d": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "type": "mesh3d" + } + ], + "parcoords": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "parcoords" + } + ], + "pie": [ + { + "automargin": true, + "type": "pie" + } + ], + "scatter": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter" + } + ], + "scatter3d": [ + { + "line": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatter3d" + } + ], + "scattercarpet": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattercarpet" + } + ], + "scattergeo": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergeo" + } + ], + "scattergl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattergl" + } + ], + "scattermapbox": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scattermapbox" + } + ], + "scatterpolar": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolar" + } + ], + "scatterpolargl": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterpolargl" + } + ], + "scatterternary": [ + { + "marker": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "type": "scatterternary" + } + ], + "surface": [ + { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + }, + "colorscale": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "type": "surface" + } + ], + "table": [ + { + "cells": { + "fill": { + "color": "#EBF0F8" + }, + "line": { + "color": "white" + } + }, + "header": { + "fill": { + "color": "#C8D4E3" + }, + "line": { + "color": "white" + } + }, + "type": "table" + } + ] + }, + "layout": { + "annotationdefaults": { + "arrowcolor": "#2a3f5f", + "arrowhead": 0, + "arrowwidth": 1 + }, + "autotypenumbers": "strict", + "coloraxis": { + "colorbar": { + "outlinewidth": 0, + "ticks": "" + } + }, + "colorscale": { + "diverging": [ + [ + 0, + "#8e0152" + ], + [ + 0.1, + "#c51b7d" + ], + [ + 0.2, + "#de77ae" + ], + [ + 0.3, + "#f1b6da" + ], + [ + 0.4, + "#fde0ef" + ], + [ + 0.5, + "#f7f7f7" + ], + [ + 0.6, + "#e6f5d0" + ], + [ + 0.7, + "#b8e186" + ], + [ + 0.8, + "#7fbc41" + ], + [ + 0.9, + "#4d9221" + ], + [ + 1, + "#276419" + ] + ], + "sequential": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ], + "sequentialminus": [ + [ + 0, + "#0d0887" + ], + [ + 0.1111111111111111, + "#46039f" + ], + [ + 0.2222222222222222, + "#7201a8" + ], + [ + 0.3333333333333333, + "#9c179e" + ], + [ + 0.4444444444444444, + "#bd3786" + ], + [ + 0.5555555555555556, + "#d8576b" + ], + [ + 0.6666666666666666, + "#ed7953" + ], + [ + 0.7777777777777778, + "#fb9f3a" + ], + [ + 0.8888888888888888, + "#fdca26" + ], + [ + 1, + "#f0f921" + ] + ] + }, + "colorway": [ + "#636efa", + "#EF553B", + "#00cc96", + "#ab63fa", + "#FFA15A", + "#19d3f3", + "#FF6692", + "#B6E880", + "#FF97FF", + "#FECB52" + ], + "font": { + "color": "#2a3f5f" + }, + "geo": { + "bgcolor": "white", + "lakecolor": "white", + "landcolor": "#E5ECF6", + "showlakes": true, + "showland": true, + "subunitcolor": "white" + }, + "hoverlabel": { + "align": "left" + }, + "hovermode": "closest", + "mapbox": { + "style": "light" + }, + "paper_bgcolor": "white", + "plot_bgcolor": "#E5ECF6", + "polar": { + "angularaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "radialaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "scene": { + "xaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "yaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + }, + "zaxis": { + "backgroundcolor": "#E5ECF6", + "gridcolor": "white", + "gridwidth": 2, + "linecolor": "white", + "showbackground": true, + "ticks": "", + "zerolinecolor": "white" + } + }, + "shapedefaults": { + "line": { + "color": "#2a3f5f" + } + }, + "ternary": { + "aaxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "baxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + }, + "bgcolor": "#E5ECF6", + "caxis": { + "gridcolor": "white", + "linecolor": "white", + "ticks": "" + } + }, + "title": { + "x": 0.05 + }, + "xaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + }, + "yaxis": { + "automargin": true, + "gridcolor": "white", + "linecolor": "white", + "ticks": "", + "title": { + "standoff": 15 + }, + "zerolinecolor": "white", + "zerolinewidth": 2 + } + } + }, + "title": { + "text": "Flow on powerline 6 (going from 3 to 4)" + }, + "xaxis": { + "title": { + "text": "Time step" + } + }, + "yaxis": { + "title": { + "text": "Production (MW)" + } + } + } + } + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from_ = 3\n", "to_ = 4\n", @@ -416,9 +3273,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "from grid2op.PlotGrid import PlotMatplot\n", "obs = copy.deepcopy(this_episode.observations[2])\n", diff --git a/grid2op/Backend/pandaPowerBackend.py b/grid2op/Backend/pandaPowerBackend.py index f532115d5..116d09080 100644 --- a/grid2op/Backend/pandaPowerBackend.py +++ b/grid2op/Backend/pandaPowerBackend.py @@ -902,7 +902,7 @@ def _apply_load_bus(self, new_bus, id_el_backend, id_topo): self._grid.load["in_service"].iat[id_el_backend] = True else: self._grid.load["in_service"].iat[id_el_backend] = False - self._grid.load["bus"].iat[id_el_backend] = -1 + # self._grid.load["bus"].iat[id_el_backend] = -1 # not needed and cause bugs with certain pandas version def _apply_gen_bus(self, new_bus, id_el_backend, id_topo): new_bus_backend = type(self).local_bus_to_global_int( @@ -919,7 +919,7 @@ def _apply_gen_bus(self, new_bus, id_el_backend, id_topo): self._grid.ext_grid["bus"].iat[0] = new_bus_backend else: self._grid.gen["in_service"].iat[id_el_backend] = False - self._grid.gen["bus"].iat[id_el_backend] = -1 + # self._grid.gen["bus"].iat[id_el_backend] = -1 # not needed and cause bugs with certain pandas version # in this case the slack bus cannot be disconnected def _apply_lor_bus(self, new_bus, id_el_backend, id_topo): diff --git a/grid2op/tests/test_notebooks_getting_started.py b/grid2op/tests/test_notebooks_getting_started.py new file mode 100644 index 000000000..b998c2117 --- /dev/null +++ b/grid2op/tests/test_notebooks_getting_started.py @@ -0,0 +1,263 @@ +# 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. + +import shutil +import copy +import os +import unittest +import time +import warnings +from grid2op.tests.helper_path_test import * + +try: + + import pdb + import nbformat + from nbconvert.preprocessors import ExecutePreprocessor, CellExecutionError + + CAN_COMPUTE = None +except ImportError as exc_: + CAN_COMPUTE = exc_ + print(exc_) + +NOTEBOOK_PATHS = os.path.abspath(os.path.join(PATH_DATA_TEST, "../../getting_started")) +VERBOSE_TIMER = True + + +def delete_all(folder): + """ + Delete all the files in a folder recursively. + + Parameters + ---------- + folder: ``str`` + The folder in which we delete everything + + Returns + ------- + None + """ + for filename in os.listdir(folder): + file_path = os.path.join(folder, filename) + try: + if os.path.isfile(file_path) or os.path.islink(file_path): + os.unlink(file_path) + elif os.path.isdir(file_path): + shutil.rmtree(file_path) + except Exception as e: + print("Failed to delete %s. Reason: %s" % (file_path, e)) + + +def export_all_notebook(folder_in): + """ + + Parameters + ---------- + folder_in: ``str`` + The folder in which we look for ipynb files + + folder_out: ``str`` + The folder in which we save the py file. + + Returns + ------- + res: ``list`` + Return the list of notebooks names + + """ + res = [] + for filename in os.listdir(folder_in): + if os.path.splitext(filename)[1] == ".ipynb": + notebook_filename = os.path.join(folder_in, filename) + res.append(notebook_filename) + return res + + +class RAII_tf_log: + def __init__(self): + self.previous = None + if "TF_CPP_MIN_LOG_LEVEL" in os.environ: + self.previous = copy.deepcopy(os.environ["TF_CPP_MIN_LOG_LEVEL"]) + os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3" + + def __del__(self): + if self.previous is not None: + os.environ["TF_CPP_MIN_LOG_LEVEL"] = self.previous + + +# notebook names are hard coded because if i change them, i need also to change the +# readme and the documentation + + +class RAII_Timer: + """ + class to have an approximation of the runtime of the notebook. + This is a rough approximation to reduce time spent in certain notebooks and should not be + used for another purpose. + """ + + def __init__(self, str_=""): + self._time = time.perf_counter() + self.str_ = str_ + + def __del__(self): + if VERBOSE_TIMER: + print( + f"Execution time for {self.str_}: {time.perf_counter() - self._time:.3f} s" + ) + + +class TestNotebook(unittest.TestCase): + def _aux_funct_notebook(self, notebook_filename): + assert os.path.exists(notebook_filename), f"{notebook_filename} do not exists!" + with open(notebook_filename) as f: + nb = nbformat.read(f, as_version=4) + try: + ep = ExecutePreprocessor(timeout=60, store_widget_state=True) + try: + ep.preprocess(nb, {"metadata": {"path": NOTEBOOK_PATHS}}) + except CellExecutionError as exc_: + raise + except Exception as exc_: + # error with tqdm progress bar i believe + pass + except CellExecutionError as exc_: + raise + except Exception: + pass + + def _check_for_baselines(self): + try: + import l2rpn_baselines + except ImportError as exc_: + self.skipTest("l2rpn baseline is not available") + + def test_notebook0_1(self): + if CAN_COMPUTE is not None: + self.skipTest(f"{CAN_COMPUTE}") + timer = RAII_Timer("test_notebook0_1") + notebook_filename = os.path.join(NOTEBOOK_PATHS, "00_SmallExample.ipynb") + self._aux_funct_notebook(notebook_filename) + + def test_notebook1(self): + if CAN_COMPUTE is not None: + self.skipTest(f"{CAN_COMPUTE}") + return # takes 80s and is useless i think, as it tests only basics things + timer = RAII_Timer("test_notebook1") + notebook_filename = os.path.join(NOTEBOOK_PATHS, "01_Grid2opFramework.ipynb") + self._aux_funct_notebook(notebook_filename) + + def test_notebook2(self): + if CAN_COMPUTE is not None: + self.skipTest(f"{CAN_COMPUTE}") + timer = RAII_Timer("test_notebook2") + notebook_filename = os.path.join(NOTEBOOK_PATHS, "02_Observation.ipynb") + self._aux_funct_notebook(notebook_filename) + + def test_notebook3(self): + if CAN_COMPUTE is not None: + self.skipTest(f"{CAN_COMPUTE}") + timer = RAII_Timer("test_notebook3") + notebook_filename = os.path.join(NOTEBOOK_PATHS, "03_Action.ipynb") + self._aux_funct_notebook(notebook_filename) + + def test_notebook4(self): + if CAN_COMPUTE is not None: + self.skipTest(f"{CAN_COMPUTE}") + self._check_for_baselines() + raii_ = RAII_tf_log() + timer = RAII_Timer("test_notebook4") + notebook_filename = os.path.join(NOTEBOOK_PATHS, "04_TrainingAnAgent.ipynb") + self._aux_funct_notebook(notebook_filename) + + def test_notebook5(self): + if CAN_COMPUTE is not None: + self.skipTest(f"{CAN_COMPUTE}") + return + timer = RAII_Timer("test_notebook5") + notebook_filename = os.path.join(NOTEBOOK_PATHS, "05_StudyYourAgent.ipynb") + self._aux_funct_notebook(notebook_filename) + + def test_notebook6(self): + if CAN_COMPUTE is not None: + self.skipTest(f"{CAN_COMPUTE}") + return + timer = RAII_Timer("test_notebook6") + notebook_filename = os.path.join( + NOTEBOOK_PATHS, "06_Redispatching_Curtailment.ipynb" + ) + self._aux_funct_notebook(notebook_filename) + + def test_notebook7(self): + if CAN_COMPUTE is not None: + self.skipTest(f"{CAN_COMPUTE}") + return + self._check_for_baselines() + raii_ = RAII_tf_log() + timer = RAII_Timer("test_notebook7") + notebook_filename = os.path.join(NOTEBOOK_PATHS, "07_MultiEnv.ipynb") + self._aux_funct_notebook(notebook_filename) + + def test_notebook8(self): + if CAN_COMPUTE is not None: + self.skipTest(f"{CAN_COMPUTE}") + + # display notebook, might not be super useful to test it in the unit test (saves another 1-2 minutes) + return + timer = RAII_Timer("test_notebook8") + notebook_filename = os.path.join( + NOTEBOOK_PATHS, "08_PlottingCapabilities.ipynb" + ) + self._aux_funct_notebook(notebook_filename) + + def test_notebook9(self): + if CAN_COMPUTE is not None: + self.skipTest(f"{CAN_COMPUTE}") + return # test the opponent and the maintenance, not much there but takes 80s so... not a lot to do + timer = RAII_Timer("test_notebook9") + notebook_filename = os.path.join( + NOTEBOOK_PATHS, "09_EnvironmentModifications.ipynb" + ) + self._aux_funct_notebook(notebook_filename) + + def test_notebook10(self): + if CAN_COMPUTE is not None: + self.skipTest(f"{CAN_COMPUTE}") + return + timer = RAII_Timer("test_notebook10") + notebook_filename = os.path.join(NOTEBOOK_PATHS, "10_StorageUnits.ipynb") + self._aux_funct_notebook(notebook_filename) + + def test_notebook_aub(self): + if CAN_COMPUTE is not None: + self.skipTest(f"{CAN_COMPUTE}") + return + raii_ = RAII_tf_log() + timer = RAII_Timer("test_notebook_aub") + notebook_filename = os.path.join( + NOTEBOOK_PATHS, + "AUB_EECE699_20201103_ReinforcementLearningApplication.ipynb", + ) + self._aux_funct_notebook(notebook_filename) + + def test_notebook_ieeebda(self): + if CAN_COMPUTE is not None: + self.skipTest(f"{CAN_COMPUTE}") + + # this test takes 3 mins alone, for a really small benefit, so i skip it for sake of time + return + self._check_for_baselines() + timer = RAII_Timer("test_notebook_ieeebda") + notebook_filename = os.path.join( + NOTEBOOK_PATHS, "IEEE BDA Tutorial Series.ipynb" + ) + self._aux_funct_notebook(notebook_filename) + + +if __name__ == "__main__": + unittest.main() \ No newline at end of file From 43d470eab81add8350c798b9bb994690f0029658 Mon Sep 17 00:00:00 2001 From: DONNOT Benjamin Date: Fri, 15 Sep 2023 10:23:30 +0200 Subject: [PATCH 11/18] adding the changelog --- CHANGELOG.rst | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 4355acfbf..cb35c7031 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -33,8 +33,11 @@ Change Log [1.9.5] - 2023-xx-yy --------------------- -- [FIXED] issue https://github.com/rte-france/Grid2Op/issues/518 -- [FIXED] issue https://github.com/rte-france/Grid2Op/issues/446 +- [FIXED] issue https://github.com/rte-france/Grid2Op/issues/518 +- [FIXED] issue https://github.com/rte-france/Grid2Op/issues/446 +- [FIXED] issue https://github.com/rte-france/Grid2Op/issues/523 by having a "_BackendAction" folder instead of a file +- [FIXED] issue https://github.com/rte-france/Grid2Op/issues/522 and adding back certain notebooks to the CI +- [FIXED] and issue when disconnecting loads / generators on msot recent pandas version [1.9.4] - 2023-09-04 --------------------- From f195a762721575ce62e1d9100ec167f30aea1d13 Mon Sep 17 00:00:00 2001 From: DONNOT Benjamin Date: Fri, 15 Sep 2023 10:44:09 +0200 Subject: [PATCH 12/18] adding some requirements for the tests --- setup.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/setup.py b/setup.py index ca25c64d6..857e3e685 100644 --- a/setup.py +++ b/setup.py @@ -71,7 +71,10 @@ def my_test_suite(): "test": ["lightsim2grid", "numba", "gym>=0.26", - "gymnasium" + "gymnasium", + "stable-baselines3>=2.0", + "nbconvert", + "jinja2" ], "chronix2grid": [ "ChroniX2Grid>=1.2.0.post1" From 6086f80f25c085a5ff5ed9656b5f0abfc1adcfde Mon Sep 17 00:00:00 2001 From: DONNOT Benjamin Date: Fri, 15 Sep 2023 11:21:31 +0200 Subject: [PATCH 13/18] fix the notebook 5, 7 and 8 and try to debug the test_notebook script --- getting_started/05_StudyYourAgent.ipynb | 2926 +---------------- getting_started/07_MultiEnv.ipynb | 157 +- getting_started/08_PlottingCapabilities.ipynb | 4 +- .../tests/test_notebooks_getting_started.py | 18 +- 4 files changed, 39 insertions(+), 3066 deletions(-) diff --git a/getting_started/05_StudyYourAgent.ipynb b/getting_started/05_StudyYourAgent.ipynb index b9ea50105..0e9d142a4 100644 --- a/getting_started/05_StudyYourAgent.ipynb +++ b/getting_started/05_StudyYourAgent.ipynb @@ -44,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -60,20 +60,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/donnotben/Documents/grid2op_dev/getting_started/grid2op/Backend/pandaPowerBackend.py:30: UserWarning: Numba cannot be loaded. You will gain possibly massive speed if installing it by \n", - "\t/usr/bin/python3 -m pip install numba\n", - "\n", - " warnings.warn(\n" - ] - } - ], + "outputs": [], "source": [ "import os\n", "import sys\n", @@ -100,31 +89,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/donnotben/Documents/grid2op_dev/getting_started/grid2op/MakeEnv/Make.py:420: UserWarning: You are using a development environment. This environment is not intended for training agents. It might not be up to date and its primary use if for tests (hence the \"test=True\" you passed as argument). Use at your own risk.\n", - " warnings.warn(_MAKE_DEV_ENV_WARN)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The results for the evaluated agent are:\n", - "\tFor chronics with id 0000\n", - "\t\t - cumulative reward: 486.856873\n", - "\t\t - number of time steps completed: 30 / 30\n", - "\tFor chronics with id 0001\n", - "\t\t - cumulative reward: 462.282471\n", - "\t\t - number of time steps completed: 30 / 30\n" - ] - } - ], + "outputs": [], "source": [ "try:\n", " from lightsim2grid import LightSimBackend\n", @@ -177,25 +144,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['0000',\n", - " 'dict_observation_space.json',\n", - " 'dict_attack_space.json',\n", - " 'dict_action_space.json',\n", - " '0001',\n", - " 'dict_env_modification_space.json']" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "os.listdir(path_agent)" ] @@ -209,23 +160,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[('/home/donnotben/Documents/grid2op_dev/getting_started/study_agent_getting_started/PowerLineSwitch',\n", - " '0000'),\n", - " ('/home/donnotben/Documents/grid2op_dev/getting_started/study_agent_getting_started/PowerLineSwitch',\n", - " '0001')]" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "from grid2op.Episode import EpisodeData\n", "episode_studied = EpisodeData.list_episode(path_agent)\n", @@ -234,7 +171,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -243,20 +180,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "datetime.datetime(2019, 1, 6, 0, 0)" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "from datetime import datetime, timedelta\n", "episode_data = this_episode\n", @@ -270,20 +196,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "next(this_episode.observations).minute_of_hour" ] @@ -304,19 +219,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total lines set to connected : 0\n", - "Total lines set to disconnected : 0\n", - "Total lines changed: 4\n" - ] - } - ], + "outputs": [], "source": [ "line_disc = 0\n", "line_reco = 0\n", @@ -342,17 +247,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total actions on powerline 14 : 1\n" - ] - } - ], + "outputs": [], "source": [ "id_line_inspected = 13\n", "actions_on_line_14 = 0\n", @@ -380,18 +277,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total hazards : 0\n", - "Total maintenances : 0\n" - ] - } - ], + "outputs": [], "source": [ "nb_hazards = 0\n", "nb_maintenance = 0\n", @@ -421,924 +309,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.plotly.v1+json": { - "config": { - "plotlyServerURL": "https://plot.ly" - }, - "data": [ - { - "type": "scatter", - "x": [ - 0, - 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 - ], - "y": [ - 87, - 89, - 88.0999984741211, - 87.5, - 88.19999694824219, - 87.80000305175781, - 88.0999984741211, - 87.5999984741211, - 87, - 85.5999984741211, - 86.4000015258789, - 84.9000015258789, - 84.30000305175781, - 84.19999694824219, - 82.80000305175781, - 85.80000305175781, - 85, - 86.5999984741211, - 84.5, - 85.80000305175781, - 85.69999694824219, - 84.19999694824219, - 84.0999984741211, - 84.9000015258789, - 83.5999984741211, - 84.19999694824219, - 82.19999694824219, - 84.30000305175781, - 84.69999694824219, - 83.5999984741211, - 85 - ] - } - ], - "layout": { - "template": { - "data": { - "bar": [ - { - "error_x": { - "color": "#2a3f5f" - }, - "error_y": { - "color": "#2a3f5f" - }, - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "bar" - } - ], - "barpolar": [ - { - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "barpolar" - } - ], - "carpet": [ - { - "aaxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "baxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "type": "carpet" - } - ], - "choropleth": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "choropleth" - } - ], - "contour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "contour" - } - ], - "contourcarpet": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "contourcarpet" - } - ], - "heatmap": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmap" - } - ], - "heatmapgl": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmapgl" - } - ], - "histogram": [ - { - "marker": { - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "histogram" - } - ], - "histogram2d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2d" - } - ], - "histogram2dcontour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2dcontour" - } - ], - "mesh3d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "mesh3d" - } - ], - "parcoords": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "parcoords" - } - ], - "pie": [ - { - "automargin": true, - "type": "pie" - } - ], - "scatter": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatter" - } - ], - "scatter3d": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatter3d" - } - ], - "scattercarpet": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattercarpet" - } - ], - "scattergeo": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergeo" - } - ], - "scattergl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergl" - } - ], - "scattermapbox": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattermapbox" - } - ], - "scatterpolar": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolar" - } - ], - "scatterpolargl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolargl" - } - ], - "scatterternary": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterternary" - } - ], - "surface": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "surface" - } - ], - "table": [ - { - "cells": { - "fill": { - "color": "#EBF0F8" - }, - "line": { - "color": "white" - } - }, - "header": { - "fill": { - "color": "#C8D4E3" - }, - "line": { - "color": "white" - } - }, - "type": "table" - } - ] - }, - "layout": { - "annotationdefaults": { - "arrowcolor": "#2a3f5f", - "arrowhead": 0, - "arrowwidth": 1 - }, - "autotypenumbers": "strict", - "coloraxis": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "colorscale": { - "diverging": [ - [ - 0, - "#8e0152" - ], - [ - 0.1, - "#c51b7d" - ], - [ - 0.2, - "#de77ae" - ], - [ - 0.3, - "#f1b6da" - ], - [ - 0.4, - "#fde0ef" - ], - [ - 0.5, - "#f7f7f7" - ], - [ - 0.6, - "#e6f5d0" - ], - [ - 0.7, - "#b8e186" - ], - [ - 0.8, - "#7fbc41" - ], - [ - 0.9, - "#4d9221" - ], - [ - 1, - "#276419" - ] - ], - "sequential": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "sequentialminus": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ] - }, - "colorway": [ - "#636efa", - "#EF553B", - "#00cc96", - "#ab63fa", - "#FFA15A", - "#19d3f3", - "#FF6692", - "#B6E880", - "#FF97FF", - "#FECB52" - ], - "font": { - "color": "#2a3f5f" - }, - "geo": { - "bgcolor": "white", - "lakecolor": "white", - "landcolor": "#E5ECF6", - "showlakes": true, - "showland": true, - "subunitcolor": "white" - }, - "hoverlabel": { - "align": "left" - }, - "hovermode": "closest", - "mapbox": { - "style": "light" - }, - "paper_bgcolor": "white", - "plot_bgcolor": "#E5ECF6", - "polar": { - "angularaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "radialaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "scene": { - "xaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "yaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "zaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - } - }, - "shapedefaults": { - "line": { - "color": "#2a3f5f" - } - }, - "ternary": { - "aaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "baxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "caxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "title": { - "x": 0.05 - }, - "xaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - }, - "yaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - } - } - }, - "title": { - "text": "Consumption of load 1" - }, - "xaxis": { - "title": { - "text": "Time step" - } - }, - "yaxis": { - "title": { - "text": "Load (MW)" - } - } - } - } - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import plotly.graph_objects as go\n", "load_id = 1\n", @@ -1368,924 +341,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.plotly.v1+json": { - "config": { - "plotlyServerURL": "https://plot.ly" - }, - "data": [ - { - "type": "scatter", - "x": [ - 0, - 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 - ], - "y": [ - 36.400001525878906, - 36.599998474121094, - 35.599998474121094, - 35.400001525878906, - 34.400001525878906, - 33.70000076293945, - 33.599998474121094, - 32.79999923706055, - 32.70000076293945, - 31.799999237060547, - 31.399999618530273, - 30.600000381469727, - 29.600000381469727, - 29.299999237060547, - 28.899999618530273, - 28, - 28, - 27.200000762939453, - 26.399999618530273, - 26.399999618530273, - 25.600000381469727, - 24.799999237060547, - 24.5, - 24.299999237060547, - 23.5, - 23.299999237060547, - 22.799999237060547, - 22.600000381469727, - 22, - 21.200000762939453, - 21 - ] - } - ], - "layout": { - "template": { - "data": { - "bar": [ - { - "error_x": { - "color": "#2a3f5f" - }, - "error_y": { - "color": "#2a3f5f" - }, - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "bar" - } - ], - "barpolar": [ - { - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "barpolar" - } - ], - "carpet": [ - { - "aaxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "baxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "type": "carpet" - } - ], - "choropleth": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "choropleth" - } - ], - "contour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "contour" - } - ], - "contourcarpet": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "contourcarpet" - } - ], - "heatmap": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmap" - } - ], - "heatmapgl": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmapgl" - } - ], - "histogram": [ - { - "marker": { - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "histogram" - } - ], - "histogram2d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2d" - } - ], - "histogram2dcontour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2dcontour" - } - ], - "mesh3d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "mesh3d" - } - ], - "parcoords": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "parcoords" - } - ], - "pie": [ - { - "automargin": true, - "type": "pie" - } - ], - "scatter": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatter" - } - ], - "scatter3d": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatter3d" - } - ], - "scattercarpet": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattercarpet" - } - ], - "scattergeo": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergeo" - } - ], - "scattergl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergl" - } - ], - "scattermapbox": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattermapbox" - } - ], - "scatterpolar": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolar" - } - ], - "scatterpolargl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolargl" - } - ], - "scatterternary": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterternary" - } - ], - "surface": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "surface" - } - ], - "table": [ - { - "cells": { - "fill": { - "color": "#EBF0F8" - }, - "line": { - "color": "white" - } - }, - "header": { - "fill": { - "color": "#C8D4E3" - }, - "line": { - "color": "white" - } - }, - "type": "table" - } - ] - }, - "layout": { - "annotationdefaults": { - "arrowcolor": "#2a3f5f", - "arrowhead": 0, - "arrowwidth": 1 - }, - "autotypenumbers": "strict", - "coloraxis": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "colorscale": { - "diverging": [ - [ - 0, - "#8e0152" - ], - [ - 0.1, - "#c51b7d" - ], - [ - 0.2, - "#de77ae" - ], - [ - 0.3, - "#f1b6da" - ], - [ - 0.4, - "#fde0ef" - ], - [ - 0.5, - "#f7f7f7" - ], - [ - 0.6, - "#e6f5d0" - ], - [ - 0.7, - "#b8e186" - ], - [ - 0.8, - "#7fbc41" - ], - [ - 0.9, - "#4d9221" - ], - [ - 1, - "#276419" - ] - ], - "sequential": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "sequentialminus": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ] - }, - "colorway": [ - "#636efa", - "#EF553B", - "#00cc96", - "#ab63fa", - "#FFA15A", - "#19d3f3", - "#FF6692", - "#B6E880", - "#FF97FF", - "#FECB52" - ], - "font": { - "color": "#2a3f5f" - }, - "geo": { - "bgcolor": "white", - "lakecolor": "white", - "landcolor": "#E5ECF6", - "showlakes": true, - "showland": true, - "subunitcolor": "white" - }, - "hoverlabel": { - "align": "left" - }, - "hovermode": "closest", - "mapbox": { - "style": "light" - }, - "paper_bgcolor": "white", - "plot_bgcolor": "#E5ECF6", - "polar": { - "angularaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "radialaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "scene": { - "xaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "yaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "zaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - } - }, - "shapedefaults": { - "line": { - "color": "#2a3f5f" - } - }, - "ternary": { - "aaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "baxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "caxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "title": { - "x": 0.05 - }, - "xaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - }, - "yaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - } - } - }, - "title": { - "text": "Production of generator 2" - }, - "xaxis": { - "title": { - "text": "Time step" - } - }, - "yaxis": { - "title": { - "text": "Production (MW)" - } - } - } - } - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "gen_id = 2\n", "# extract the data\n", @@ -2314,924 +372,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.plotly.v1+json": { - "config": { - "plotlyServerURL": "https://plot.ly" - }, - "data": [ - { - "type": "scatter", - "x": [ - 0, - 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 - ], - "y": [ - 137.96974182128906, - 72.48875427246094, - 69.81539916992188, - 72.50433349609375, - 72.38471984863281, - 71.48223114013672, - 70.87670135498047, - 68.60836029052734, - 67.214111328125, - 67.40162658691406, - 66.00444030761719, - 65.37370300292969, - 62.280765533447266, - 62.12760925292969, - 61.809505462646484, - 60.048377990722656, - 60.349159240722656, - 60.78220748901367, - 58.05248260498047, - 57.39665603637695, - 55.339229583740234, - 53.9398193359375, - 54.09462356567383, - 55.7864875793457, - 53.59382247924805, - 53.371826171875, - 52.07499313354492, - 53.45325469970703, - 52.256771087646484, - 50.28155517578125, - 50.90947341918945 - ] - } - ], - "layout": { - "template": { - "data": { - "bar": [ - { - "error_x": { - "color": "#2a3f5f" - }, - "error_y": { - "color": "#2a3f5f" - }, - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "bar" - } - ], - "barpolar": [ - { - "marker": { - "line": { - "color": "#E5ECF6", - "width": 0.5 - }, - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "barpolar" - } - ], - "carpet": [ - { - "aaxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "baxis": { - "endlinecolor": "#2a3f5f", - "gridcolor": "white", - "linecolor": "white", - "minorgridcolor": "white", - "startlinecolor": "#2a3f5f" - }, - "type": "carpet" - } - ], - "choropleth": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "choropleth" - } - ], - "contour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "contour" - } - ], - "contourcarpet": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "contourcarpet" - } - ], - "heatmap": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmap" - } - ], - "heatmapgl": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "heatmapgl" - } - ], - "histogram": [ - { - "marker": { - "pattern": { - "fillmode": "overlay", - "size": 10, - "solidity": 0.2 - } - }, - "type": "histogram" - } - ], - "histogram2d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2d" - } - ], - "histogram2dcontour": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "histogram2dcontour" - } - ], - "mesh3d": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "type": "mesh3d" - } - ], - "parcoords": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "parcoords" - } - ], - "pie": [ - { - "automargin": true, - "type": "pie" - } - ], - "scatter": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatter" - } - ], - "scatter3d": [ - { - "line": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatter3d" - } - ], - "scattercarpet": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattercarpet" - } - ], - "scattergeo": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergeo" - } - ], - "scattergl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattergl" - } - ], - "scattermapbox": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scattermapbox" - } - ], - "scatterpolar": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolar" - } - ], - "scatterpolargl": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterpolargl" - } - ], - "scatterternary": [ - { - "marker": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "type": "scatterternary" - } - ], - "surface": [ - { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - }, - "colorscale": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "type": "surface" - } - ], - "table": [ - { - "cells": { - "fill": { - "color": "#EBF0F8" - }, - "line": { - "color": "white" - } - }, - "header": { - "fill": { - "color": "#C8D4E3" - }, - "line": { - "color": "white" - } - }, - "type": "table" - } - ] - }, - "layout": { - "annotationdefaults": { - "arrowcolor": "#2a3f5f", - "arrowhead": 0, - "arrowwidth": 1 - }, - "autotypenumbers": "strict", - "coloraxis": { - "colorbar": { - "outlinewidth": 0, - "ticks": "" - } - }, - "colorscale": { - "diverging": [ - [ - 0, - "#8e0152" - ], - [ - 0.1, - "#c51b7d" - ], - [ - 0.2, - "#de77ae" - ], - [ - 0.3, - "#f1b6da" - ], - [ - 0.4, - "#fde0ef" - ], - [ - 0.5, - "#f7f7f7" - ], - [ - 0.6, - "#e6f5d0" - ], - [ - 0.7, - "#b8e186" - ], - [ - 0.8, - "#7fbc41" - ], - [ - 0.9, - "#4d9221" - ], - [ - 1, - "#276419" - ] - ], - "sequential": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ], - "sequentialminus": [ - [ - 0, - "#0d0887" - ], - [ - 0.1111111111111111, - "#46039f" - ], - [ - 0.2222222222222222, - "#7201a8" - ], - [ - 0.3333333333333333, - "#9c179e" - ], - [ - 0.4444444444444444, - "#bd3786" - ], - [ - 0.5555555555555556, - "#d8576b" - ], - [ - 0.6666666666666666, - "#ed7953" - ], - [ - 0.7777777777777778, - "#fb9f3a" - ], - [ - 0.8888888888888888, - "#fdca26" - ], - [ - 1, - "#f0f921" - ] - ] - }, - "colorway": [ - "#636efa", - "#EF553B", - "#00cc96", - "#ab63fa", - "#FFA15A", - "#19d3f3", - "#FF6692", - "#B6E880", - "#FF97FF", - "#FECB52" - ], - "font": { - "color": "#2a3f5f" - }, - "geo": { - "bgcolor": "white", - "lakecolor": "white", - "landcolor": "#E5ECF6", - "showlakes": true, - "showland": true, - "subunitcolor": "white" - }, - "hoverlabel": { - "align": "left" - }, - "hovermode": "closest", - "mapbox": { - "style": "light" - }, - "paper_bgcolor": "white", - "plot_bgcolor": "#E5ECF6", - "polar": { - "angularaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "radialaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "scene": { - "xaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "yaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - }, - "zaxis": { - "backgroundcolor": "#E5ECF6", - "gridcolor": "white", - "gridwidth": 2, - "linecolor": "white", - "showbackground": true, - "ticks": "", - "zerolinecolor": "white" - } - }, - "shapedefaults": { - "line": { - "color": "#2a3f5f" - } - }, - "ternary": { - "aaxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "baxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - }, - "bgcolor": "#E5ECF6", - "caxis": { - "gridcolor": "white", - "linecolor": "white", - "ticks": "" - } - }, - "title": { - "x": 0.05 - }, - "xaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - }, - "yaxis": { - "automargin": true, - "gridcolor": "white", - "linecolor": "white", - "ticks": "", - "title": { - "standoff": 15 - }, - "zerolinecolor": "white", - "zerolinewidth": 2 - } - } - }, - "title": { - "text": "Flow on powerline 6 (going from 3 to 4)" - }, - "xaxis": { - "title": { - "text": "Time step" - } - }, - "yaxis": { - "title": { - "text": "Production (MW)" - } - } - } - } - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from_ = 3\n", "to_ = 4\n", @@ -3273,22 +416,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from grid2op.PlotGrid import PlotMatplot\n", "obs = copy.deepcopy(this_episode.observations[2])\n", diff --git a/getting_started/07_MultiEnv.ipynb b/getting_started/07_MultiEnv.ipynb index 0654ffa5a..44313f4c7 100644 --- a/getting_started/07_MultiEnv.ipynb +++ b/getting_started/07_MultiEnv.ipynb @@ -266,7 +266,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### III.b) Practical example\n", + "### III.b) Practical example (work in progress)\n", "\n", "We reuse the code of the Notebook [04_TrainingAnAgent](04_TrainingAnAgent.ipynb) to train a new agent we strongly recommend you to have a look at it if it is not done already.\n", "\n", @@ -284,163 +284,8 @@ "\n", "This is especially suited in the case of powersystem operations, as it can be quite computationnally expensive to solve for the powerflow equations at each nodes of the grid (also called [Kirchhoff's laws](https://en.wikipedia.org/wiki/Kirchhoff%27s_circuit_laws))\n", "\n", - "#### What you have to do\n", - "\n", - "We recall here the code that we used in the relevant notebook to train the agent:\n", - "```python\n", - "# create an environment\n", - "env = make(env_name, test=True) \n", - "# don't forget to set \"test=False\" (or remove it, as False is the default value) for \"real\" training\n", - "\n", - "# import the train function and train your agent\n", - "from l2rpn_baselines.DuelQSimple import train\n", - "from l2rpn_baselines.utils import NNParam, TrainingParam\n", - "agent_name = \"test_agent\"\n", - "save_path = \"saved_agent_DDDQN_{}\".format(train_iter)\n", - "logs_dir=\"tf_logs_DDDQN\"\n", - "\n", - "\n", - "# we then define the neural network we want to make (you may change this at will)\n", - "## 1. first we choose what \"part\" of the observation we want as input, \n", - "## here for example only the generator and load information\n", - "## see https://grid2op.readthedocs.io/en/latest/observation.html#main-observation-attributes\n", - "## for the detailed about all the observation attributes you want to have\n", - "li_attr_obs_X = [\"gen_p\", \"gen_v\", \"load_p\", \"load_q\"]\n", - "# this automatically computes the size of the resulting vector\n", - "observation_size = NNParam.get_obs_size(env, li_attr_obs_X) \n", - "\n", - "## 2. then we define its architecture\n", - "sizes = [300, 300, 300] # 3 hidden layers, of 300 units each, why not...\n", - "activs = [\"relu\" for _ in sizes] # all followed by relu activation, because... why not\n", - "## 4. you put it all on a dictionnary like that (specific to this baseline)\n", - "kwargs_archi = {'observation_size': observation_size,\n", - " 'sizes': sizes,\n", - " 'activs': activs,\n", - " \"list_attr_obs\": li_attr_obs_X}\n", - "\n", - "# you can also change the training parameters you are using\n", - "# more information at https://l2rpn-baselines.readthedocs.io/en/latest/utils.html#l2rpn_baselines.utils.TrainingParam\n", - "tp = TrainingParam()\n", - "tp.batch_size = 32 # for example...\n", - "tp.update_tensorboard_freq = int(train_iter / 10)\n", - "tp.save_model_each = int(train_iter / 3)\n", - "tp.min_observation = int(train_iter / 5)\n", - "train(env,\n", - " name=agent_name,\n", - " iterations=train_iter,\n", - " save_path=save_path,\n", - " load_path=None, # put something else if you want to reload an agent instead of creating a new one\n", - " logs_dir=logs_dir,\n", - " kwargs_archi=kwargs_archi,\n", - " training_param=tp)\n", - "```\n", - "\n", "Here, you will see in the next cell how to (*not really*) change it to train a agent on different environments:" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "train_iter = TRAINING_STEP\n", - "# import the train function and train your agent\n", - "from l2rpn_baselines.DuelQSimple import train\n", - "from l2rpn_baselines.utils import NNParam, TrainingParam, make_multi_env\n", - "agent_name = \"test_agent_multi\"\n", - "save_path = \"saved_agent_DDDQN_{}_multi\".format(train_iter)\n", - "logs_dir=\"tf_logs_DDDQN\"\n", - "\n", - "# just add the relevant import (see above) and this line\n", - "my_envs = make_multi_env(env_init=env, nb_env=NUM_CORE)\n", - "# and that's it !\n", - "\n", - "\n", - "# we then define the neural network we want to make (you may change this at will)\n", - "## 1. first we choose what \"part\" of the observation we want as input, \n", - "## here for example only the generator and load information\n", - "## see https://grid2op.readthedocs.io/en/latest/observation.html#main-observation-attributes\n", - "## for the detailed about all the observation attributes you want to have\n", - "li_attr_obs_X = [\"gen_p\", \"gen_v\", \"load_p\", \"load_q\"]\n", - "# this automatically computes the size of the resulting vector\n", - "observation_size = NNParam.get_obs_size(env, li_attr_obs_X) \n", - "\n", - "## 2. then we define its architecture\n", - "sizes = [300, 300, 300] # 3 hidden layers, of 300 units each, why not...\n", - "activs = [\"relu\" for _ in sizes] # all followed by relu activation, because... why not\n", - "## 4. you put it all on a dictionnary like that (specific to this baseline)\n", - "kwargs_archi = {'observation_size': observation_size,\n", - " 'sizes': sizes,\n", - " 'activs': activs,\n", - " \"list_attr_obs\": li_attr_obs_X}\n", - "\n", - "# you can also change the training parameters you are using\n", - "# more information at https://l2rpn-baselines.readthedocs.io/en/latest/utils.html#l2rpn_baselines.utils.TrainingParam\n", - "tp = TrainingParam()\n", - "tp.batch_size = 32 # for example...\n", - "tp.update_tensorboard_freq = int(train_iter / 10)\n", - "tp.save_model_each = int(train_iter / 3)\n", - "tp.min_observation = int(train_iter / 5)\n", - "train(my_envs,\n", - " name=agent_name,\n", - " iterations=train_iter,\n", - " save_path=save_path,\n", - " load_path=None, # put something else if you want to reload an agent instead of creating a new one\n", - " logs_dir=logs_dir,\n", - " kwargs_archi=kwargs_archi,\n", - " training_param=tp)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### II c) Assess the performance of the trained agent" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Nothing is changing... Like really, it's the same code as in notebook 4 (we told you to have a look ;-) )" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from l2rpn_baselines.DuelQSimple import evaluate\n", - "path_save_results = \"{}_results_multi\".format(save_path)\n", - "\n", - "evaluated_agent, res_runner = evaluate(env,\n", - " name=agent_name,\n", - " load_path=save_path,\n", - " logs_path=path_save_results,\n", - " nb_episode=2,\n", - " nb_process=1,\n", - " max_steps=100,\n", - " verbose=True,\n", - " save_gif=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### II d) That is it ?\n", - "\n", - "Yes there is nothing more to say about it. As long as you use one of the compatible baselines (at the date of writing):\n", - "- [DeepQSimple](https://l2rpn-baselines.readthedocs.io/en/master/DeepQSimple.html)\n", - "- [DuelQSimple](https://l2rpn-baselines.readthedocs.io/en/master/DuelQSimple.html)\n", - "- [DuelQLeapNet](https://l2rpn-baselines.readthedocs.io/en/master/DuelQLeapNet.html)\n", - "\n", - "You do not have anything more to do :-)\n", - "\n", - "If you want to use another baseline that does not support this feature, feel free to add an issue in the l2rpn-baselines official github at this adress [https://github.com/rte-france/l2rpn-baselines/issues](https://github.com/rte-france/l2rpn-baselines/issues)" - ] } ], "metadata": { diff --git a/getting_started/08_PlottingCapabilities.ipynb b/getting_started/08_PlottingCapabilities.ipynb index e6d62db0a..5c6ccb012 100644 --- a/getting_started/08_PlottingCapabilities.ipynb +++ b/getting_started/08_PlottingCapabilities.ipynb @@ -302,7 +302,7 @@ "outputs": [], "source": [ "from grid2op.Runner import Runner\n", - "env = grid2op.make(test=True)\n", + "env = grid2op.make(\"l2rpn_case14_sandbox\", test=True)\n", "my_awesome_agent = CustomRandom(env.action_space)\n", "runner = Runner(**env.get_params_for_runner(), agentClass=None, agentInstance=my_awesome_agent)" ] @@ -501,7 +501,7 @@ "source": [ "# If you want to start grid2viz for better plotting, you may try the following :\n", "# (remove the \"if False:\" or replace it with \"if True:\")\n", - "if True:\n", + "if False:\n", " !$sys.executable -m grid2viz.main --agents_path $path_agents\n", "else:\n", " print(\"You need to copy paste the command in the cell above to run grid2viz\")" diff --git a/grid2op/tests/test_notebooks_getting_started.py b/grid2op/tests/test_notebooks_getting_started.py index b998c2117..80d86dd72 100644 --- a/grid2op/tests/test_notebooks_getting_started.py +++ b/grid2op/tests/test_notebooks_getting_started.py @@ -1,4 +1,4 @@ -# Copyright (c) 2019-2020, RTE (https://www.rte-france.com) +# Copyright (c) 2019-2023, 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, @@ -6,24 +6,26 @@ # SPDX-License-Identifier: MPL-2.0 # This file is part of Grid2Op, Grid2Op a testbed platform to model sequential decision making in power systems. +print("Beginning to import here") import shutil import copy import os import unittest import time import warnings -from grid2op.tests.helper_path_test import * +import pdb try: - - import pdb import nbformat from nbconvert.preprocessors import ExecutePreprocessor, CellExecutionError - CAN_COMPUTE = None except ImportError as exc_: CAN_COMPUTE = exc_ - print(exc_) + print(f"Import error : {exc_}") +print("End of the regulart import here") + +from grid2op.tests.helper_path_test import PATH_DATA_TEST +print("End of all imports here") NOTEBOOK_PATHS = os.path.abspath(os.path.join(PATH_DATA_TEST, "../../getting_started")) VERBOSE_TIMER = True @@ -178,7 +180,6 @@ def test_notebook4(self): def test_notebook5(self): if CAN_COMPUTE is not None: self.skipTest(f"{CAN_COMPUTE}") - return timer = RAII_Timer("test_notebook5") notebook_filename = os.path.join(NOTEBOOK_PATHS, "05_StudyYourAgent.ipynb") self._aux_funct_notebook(notebook_filename) @@ -186,7 +187,6 @@ def test_notebook5(self): def test_notebook6(self): if CAN_COMPUTE is not None: self.skipTest(f"{CAN_COMPUTE}") - return timer = RAII_Timer("test_notebook6") notebook_filename = os.path.join( NOTEBOOK_PATHS, "06_Redispatching_Curtailment.ipynb" @@ -196,7 +196,6 @@ def test_notebook6(self): def test_notebook7(self): if CAN_COMPUTE is not None: self.skipTest(f"{CAN_COMPUTE}") - return self._check_for_baselines() raii_ = RAII_tf_log() timer = RAII_Timer("test_notebook7") @@ -228,7 +227,6 @@ def test_notebook9(self): def test_notebook10(self): if CAN_COMPUTE is not None: self.skipTest(f"{CAN_COMPUTE}") - return timer = RAII_Timer("test_notebook10") notebook_filename = os.path.join(NOTEBOOK_PATHS, "10_StorageUnits.ipynb") self._aux_funct_notebook(notebook_filename) From 1a55d2a5a0d33407a33b7a0db3f87da0b75072a2 Mon Sep 17 00:00:00 2001 From: DONNOT Benjamin Date: Fri, 15 Sep 2023 11:55:17 +0200 Subject: [PATCH 14/18] still trying to fix the error of notebook on the ci --- grid2op/__init__.py | 2 +- grid2op/tests/test_notebooks_getting_started.py | 17 ++++++++++++++--- 2 files changed, 15 insertions(+), 4 deletions(-) diff --git a/grid2op/__init__.py b/grid2op/__init__.py index 481fdcafb..315237735 100644 --- a/grid2op/__init__.py +++ b/grid2op/__init__.py @@ -11,7 +11,7 @@ Grid2Op """ -__version__ = '1.9.4' +__version__ = '1.9.5.dev0' __all__ = [ "Action", diff --git a/grid2op/tests/test_notebooks_getting_started.py b/grid2op/tests/test_notebooks_getting_started.py index 80d86dd72..e77bb44a9 100644 --- a/grid2op/tests/test_notebooks_getting_started.py +++ b/grid2op/tests/test_notebooks_getting_started.py @@ -14,21 +14,32 @@ import time import warnings import pdb +import subprocess +import sys try: + # Import error : Jupyter is migrating its paths to use standard platformdirs + # given by the platformdirs library. To remove this warning and + # see the appropriate new directories, set the environment variable + # `JUPYTER_PLATFORM_DIRS=1` and then run `jupyter --paths`. + # The use of platformdirs will be the default in `jupyter_core` v6 + os.environ["JUPYTER_PLATFORM_DIRS"] = "1" + subprocess.call([f"{sys.executable}", "-m", "jupyter", "--paths"]) + # the above 2 lines are to fix the above error + import nbformat from nbconvert.preprocessors import ExecutePreprocessor, CellExecutionError CAN_COMPUTE = None -except ImportError as exc_: +except Exception as exc_: CAN_COMPUTE = exc_ print(f"Import error : {exc_}") print("End of the regulart import here") from grid2op.tests.helper_path_test import PATH_DATA_TEST -print("End of all imports here") NOTEBOOK_PATHS = os.path.abspath(os.path.join(PATH_DATA_TEST, "../../getting_started")) VERBOSE_TIMER = True +print("End of all imports here") def delete_all(folder): @@ -114,7 +125,7 @@ def __del__(self): ) -class TestNotebook(unittest.TestCase): +class TestNotebooks(unittest.TestCase): def _aux_funct_notebook(self, notebook_filename): assert os.path.exists(notebook_filename), f"{notebook_filename} do not exists!" with open(notebook_filename) as f: From 5ee73ab7c9261b681058df3c55950ba80ad1f181 Mon Sep 17 00:00:00 2001 From: DONNOT Benjamin Date: Fri, 15 Sep 2023 13:09:09 +0200 Subject: [PATCH 15/18] let's see if bug is fixed --- grid2op/tests/test_notebooks_getting_started.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/grid2op/tests/test_notebooks_getting_started.py b/grid2op/tests/test_notebooks_getting_started.py index e77bb44a9..1441595c5 100644 --- a/grid2op/tests/test_notebooks_getting_started.py +++ b/grid2op/tests/test_notebooks_getting_started.py @@ -6,7 +6,6 @@ # SPDX-License-Identifier: MPL-2.0 # This file is part of Grid2Op, Grid2Op a testbed platform to model sequential decision making in power systems. -print("Beginning to import here") import shutil import copy import os @@ -24,7 +23,7 @@ # `JUPYTER_PLATFORM_DIRS=1` and then run `jupyter --paths`. # The use of platformdirs will be the default in `jupyter_core` v6 os.environ["JUPYTER_PLATFORM_DIRS"] = "1" - subprocess.call([f"{sys.executable}", "-m", "jupyter", "--paths"]) + subprocess.run([f"{sys.executable}", "-m", "jupyter", "--paths"], capture_output=True, env=os.environ) # the above 2 lines are to fix the above error import nbformat @@ -33,13 +32,11 @@ except Exception as exc_: CAN_COMPUTE = exc_ print(f"Import error : {exc_}") -print("End of the regulart import here") from grid2op.tests.helper_path_test import PATH_DATA_TEST NOTEBOOK_PATHS = os.path.abspath(os.path.join(PATH_DATA_TEST, "../../getting_started")) VERBOSE_TIMER = True -print("End of all imports here") def delete_all(folder): From 9a91949dc88a674b0c97bd81c36b9e3822c229e5 Mon Sep 17 00:00:00 2001 From: DONNOT Benjamin Date: Fri, 15 Sep 2023 17:17:29 +0200 Subject: [PATCH 16/18] adressing issue rte-france#527 --- .gitignore | 1 + CHANGELOG.rst | 5 +++- grid2op/Action/baseAction.py | 30 +++++++++++++++++++++- grid2op/tests/test_issue_511.py | 3 +++ grid2op/tests/test_issue_527.py | 44 +++++++++++++++++++++++++++++++++ 5 files changed, 81 insertions(+), 2 deletions(-) create mode 100644 grid2op/tests/test_issue_527.py diff --git a/.gitignore b/.gitignore index c97dd3095..b7b8900c8 100644 --- a/.gitignore +++ b/.gitignore @@ -391,6 +391,7 @@ _profiling/profile.json actspace_converter.py grid2op/data_test/input_data_local/ test_sim2real_battery.py +grid2op/tests/list_test_debug # profiling files **.prof diff --git a/CHANGELOG.rst b/CHANGELOG.rst index cb35c7031..3a744fc01 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -37,7 +37,10 @@ Change Log - [FIXED] issue https://github.com/rte-france/Grid2Op/issues/446 - [FIXED] issue https://github.com/rte-france/Grid2Op/issues/523 by having a "_BackendAction" folder instead of a file - [FIXED] issue https://github.com/rte-france/Grid2Op/issues/522 and adding back certain notebooks to the CI -- [FIXED] and issue when disconnecting loads / generators on msot recent pandas version +- [FIXED] an issue when disconnecting loads / generators on msot recent pandas version +- [FIXED] issue https://github.com/rte-france/Grid2Op/issues/527 : now do nothing action are detected in + `act.as_serializable_dict()` AND weird do nothing action can be made through the action space + (`env.action_space({"change_bus": {}})` is not ambiguous, though might not be super efficient...) [1.9.4] - 2023-09-04 --------------------- diff --git a/grid2op/Action/baseAction.py b/grid2op/Action/baseAction.py index 8c58c9145..02e3770f1 100644 --- a/grid2op/Action/baseAction.py +++ b/grid2op/Action/baseAction.py @@ -612,10 +612,16 @@ def as_serializable_dict(self) -> dict: res["raise_alert"] = [ int(id_) for id_, val in enumerate(self._raise_alert) if val ] + if not res["raise_alert"]: + del res["raise_alert"] + if self._modif_alarm: res["raise_alarm"] = [ int(id_) for id_, val in enumerate(self._raise_alarm) if val ] + if not res["raise_alarm"]: + del res["raise_alarm"] + if self._modif_change_bus: res["change_bus"] = {} self._aux_serialize_add_key_change("load_change_bus", "loads_id", res["change_bus"]) @@ -623,11 +629,15 @@ def as_serializable_dict(self) -> dict: self._aux_serialize_add_key_change("line_or_change_bus", "lines_or_id", res["change_bus"]) self._aux_serialize_add_key_change("line_ex_change_bus", "lines_ex_id", res["change_bus"]) self._aux_serialize_add_key_change("storage_change_bus", "storages_id", res["change_bus"]) + if not res["change_bus"]: + del res["change_bus"] if self._modif_change_status: res["change_line_status"] = [ int(id_) for id_, val in enumerate(self._switch_line_status) if val ] + if not res["change_line_status"]: + del res["change_line_status"] # int elements if self._modif_set_bus: @@ -637,6 +647,8 @@ def as_serializable_dict(self) -> dict: self._aux_serialize_add_key_set("line_or_set_bus", "lines_or_id", res["set_bus"]) self._aux_serialize_add_key_set("line_ex_set_bus", "lines_ex_id", res["set_bus"]) self._aux_serialize_add_key_set("storage_set_bus", "storages_id", res["set_bus"]) + if not res["set_bus"]: + del res["set_bus"] if self._modif_set_status: res["set_line_status"] = [ @@ -644,6 +656,8 @@ def as_serializable_dict(self) -> dict: for id_, val in enumerate(self._set_line_status) if val != 0 ] + if not res["set_line_status"]: + del res["set_line_status"] # float elements if self._modif_redispatch: @@ -652,18 +666,26 @@ def as_serializable_dict(self) -> dict: for id_, val in enumerate(self._redispatch) if val != 0.0 ] + if not res["redispatch"]: + del res["redispatch"] + if self._modif_storage: res["set_storage"] = [ (int(id_), float(val)) for id_, val in enumerate(self._storage_power) if val != 0.0 ] + if not res["set_storage"]: + del res["set_storage"] + if self._modif_curtailment: res["curtail"] = [ (int(id_), float(val)) for id_, val in enumerate(self._curtail) if val != -1 ] + if not res["curtail"]: + del res["curtail"] # more advanced options if self._modif_inj: @@ -1787,7 +1809,7 @@ def _digest_setbus(self, dict_): if dict_["set_bus"] is None: # no real action has been made return - + if isinstance(dict_["set_bus"], dict): ddict_ = dict_["set_bus"] handled = False @@ -1809,6 +1831,9 @@ def _digest_setbus(self, dict_): if "substations_id" in ddict_: self.sub_set_bus = ddict_["substations_id"] handled = True + if ddict_ == {}: + handled = True + # weird way to do nothing but hey, how am I to judge ? if not handled: msg = 'Invalid way to set the topology. When dict_["set_bus"] is a dictionary it should have' msg += ( @@ -1849,6 +1874,9 @@ def _digest_change_bus(self, dict_): if "substations_id" in ddict_: self.sub_change_bus = ddict_["substations_id"] handled = True + if ddict_ == {}: + handled = True + # weird way to do nothing but hey, how am I to judge ? if not handled: msg = 'Invalid way to change the topology. When dict_["set_bus"] is a dictionary it should have' msg += ( diff --git a/grid2op/tests/test_issue_511.py b/grid2op/tests/test_issue_511.py index 8499042a6..0303c32ac 100644 --- a/grid2op/tests/test_issue_511.py +++ b/grid2op/tests/test_issue_511.py @@ -21,6 +21,9 @@ def setUp(self) -> None: test=True ) return super().setUp() + + def tearDown(self): + self.env.close() def test_issue_set_bus(self): act = { diff --git a/grid2op/tests/test_issue_527.py b/grid2op/tests/test_issue_527.py new file mode 100644 index 000000000..3b7a6e381 --- /dev/null +++ b/grid2op/tests/test_issue_527.py @@ -0,0 +1,44 @@ + +# Copyright (c) 2023, 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. + +import grid2op +import warnings +import unittest +import pdb + + +class Issue527Tester(unittest.TestCase): + def setUp(self) -> None: + with warnings.catch_warnings(): + warnings.filterwarnings("ignore") + self.env = grid2op.make( + "l2rpn_case14_sandbox", + test=True + ) + self.env.seed(0) + return super().setUp() + + def tearDown(self): + self.env.close() + + def test_action_space_sampling(self) -> None: + obs = self.env.reset() + for ind in range(1000): + act = self.env.action_space.sample() + act_dict = act.as_serializable_dict() + self.env.action_space(act_dict) + + def test_do_nothing_act_weird(self) -> None: + obs = self.env.reset() + self.env.action_space({"change_bus": {}}) + self.env.action_space({"set_bus": {}}) + + +if __name__ == '__main__': + unittest.main() From 0732a656f5b5d381f1338329b8ece4c58cb629c2 Mon Sep 17 00:00:00 2001 From: DONNOT Benjamin Date: Mon, 18 Sep 2023 09:21:07 +0200 Subject: [PATCH 17/18] fix broken test --- grid2op/tests/test_act_as_serializable_dict.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/grid2op/tests/test_act_as_serializable_dict.py b/grid2op/tests/test_act_as_serializable_dict.py index d36be3208..479f8e7f8 100644 --- a/grid2op/tests/test_act_as_serializable_dict.py +++ b/grid2op/tests/test_act_as_serializable_dict.py @@ -317,7 +317,7 @@ def test_all_at_once(self): ] } ) - act += self.helper_action({"change_line_status": [l_id for l_id in [2, 4, 5]]}) + act += self.helper_action({"change_line_status": [l_id for l_id in [6, 7, 8]]}) act += self.helper_action( { "set_bus": [ From a07b57087ca9afff5b4bcc9f1851016cf51a6f0c Mon Sep 17 00:00:00 2001 From: DONNOT Benjamin Date: Mon, 18 Sep 2023 15:08:03 +0200 Subject: [PATCH 18/18] ready for next release [skip ci] --- CHANGELOG.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.rst b/CHANGELOG.rst index 3a744fc01..a13bb88dc 100644 --- a/CHANGELOG.rst +++ b/CHANGELOG.rst @@ -31,7 +31,7 @@ Change Log - [???] "asynch" multienv - [???] properly model interconnecting powerlines -[1.9.5] - 2023-xx-yy +[1.9.5] - 2023-09-18 --------------------- - [FIXED] issue https://github.com/rte-france/Grid2Op/issues/518 - [FIXED] issue https://github.com/rte-france/Grid2Op/issues/446