Method step

src/pymgrid/microgrid/microgrid.py:233–346

Run the microgrid for a single step. Parameters ---------- control : dict[str, list[float]] Actions to pass to each fixed module. normalized : bool, default True Whether ``control`` is a normalized value or not. If not, each module d

(self, control, normalized=True)

        pass

    def step(self, control, normalized=True):
        """

        Run the microgrid for a single step.

        Parameters
        ----------
        control : dict[str, list[float]]
            Actions to pass to each fixed module.
        normalized : bool, default True
            Whether ``control`` is a normalized value or not. If not, each module de-normalizes its respective action.

        Returns
        -------
        observation : dict[str, list[float]]
            Observations of each module after using the passed ``control``.
        reward : float
            Reward/cost of running the microgrid. A positive value implies revenue while a negative
            value is a cost.
        done : bool
            Whether the microgrid terminates.
        info : dict
            Additional information from this step.

        """
        control_copy = control.copy()
        microgrid_step = MicrogridStep(reward_shaping_func=self.reward_shaping_func, cost_info=self.get_cost_info())

        for name, modules in self.fixed.iterdict():
            for module in modules:
                microgrid_step.append(name, *module.step(0.0, normalized=False))

        fixed_provided, fixed_consumed, _, _ = microgrid_step.balance()
        log_dict = self._get_log_dict(fixed_provided, fixed_consumed, prefix='fixed')

        for name, modules in self.controllable.iterdict():
            try:
                module_controls = control_copy.pop(name)
            except KeyError:
                raise ValueError(f'Control for module "{name}" not found. Available controls:\n\t{control.keys()}')
            else:
                try:
                    _zip = zip(modules, module_controls)
                except TypeError:
                    _zip = zip(modules, [module_controls])

            for module, _control in _zip:
                module_step = module.step(_control, normalized=normalized)  # obs, reward, done, info.
                microgrid_step.append(name, *module_step)

        controllable_fixed_provided, controllable_fixed_consumed, _, _ = microgrid_step.balance()
        difference = controllable_fixed_provided - controllable_fixed_consumed

        log_dict = self._get_log_dict(
            controllable_fixed_provided-fixed_provided,
            controllable_fixed_consumed-fixed_consumed,
            log_dict=log_dict,
            prefix='controllable'