def __init__(self, wdir, options_file=None, webapp=False, logging_level=logging.INFO): self.wdir = wdir self.package_dir = Path(pomato.__path__[0]) self.logger = _logging_setup(self.wdir, webapp, logging_level) self.logger.info("Market Tool Initialized") tools.create_folder_structure(self.wdir, self.logger) # Core Attributes if not options_file: self.options = tools.default_options() else: self.initialize_options(options_file) self.data = DataManagement(self.options, self.wdir) self.grid = None self.cbco_module = None self.grid_representation = None self.market_model = None self.bokeh_plot = None
def __init__(self, options_file=None, webapp=False, wdir=None): self.wdir = wdir if wdir else Path.cwd() self.logger = _logging_setup(self.wdir, webapp) self.logger.info("Market Tool Initialized") tools.create_folder_structure(self.wdir, self.logger) # Core Attributes self.options = None self.initialize_options(options_file) self.data = DataManagement(self.options, self.wdir) self.grid = None self.cbco_module = None self.grid_representation = None self.market_model = None self.bokeh_plot = None
def load_data(self, filename): """Load data into data_management module. The data attribute is initialized empty and explicitly filled with this method. When done reading and processing data, the grid model is also initialized. Parameters ---------- filename : str Providing the name of a data file, usually located in the ``/input_data`` folder. Excel files and matpower cases are supported. """ self.data = DataManagement(self.options, self.wdir) self.data.load_data(filename) self.grid = GridModel(self.data.nodes, self.data.lines) self.cbco_module = CBCOModule(self.wdir, self.package_dir, self.grid, self.data, self.options) self.market_model = MarketModel(self.wdir, self.package_dir, self.options)
def _clear_data(self): """Reset DataManagement Class.""" self.logger.info("Resetting Data Object") self.data = DataManagement()
class POMATO(): """ The main module joins POMATO's components, providing accessibility to the user. The core attributes are modules that provide specific functionalities to the model. At the center is an instance of the DataManagement module, that reads and processes input data, makes processed input data acessible to other modules and is the container for the results from the market model. Attributes ---------- wdir : pathlib.Path Working directory, all necessary folders, temporary files and results are stored in relation to this directory. options : dict Dictionalry containing centralized all options relevant for running an economic dispatch. The options are roughly cathegorized into: - Optimization: defining model type, model horizon, inclusion of model features like heat or curtailment, management of infeasibility variables and definition of plant types considered. - Grid: Setting Capacity multiplier, applying redundancy removal for contingency analysis and its sensitivity, for zonal representation setting the node-zone weights. - Data: data type, data that is stored stacked (opposed to long), options to process marginal costs to be unique and default values. data : :class:`~pomato.data.DataManagement` Instance of DataManagement class containing all data, data processing, results and result processing. Is initialized empty, then data explicitly loaded. grid : :class:`~pomato.grid.GridModel` Object containing all grid information. Initializes empty and filled based on nodes and lines data when it is loaded and processed. Provides the PTDF matrices for N-0 and N-1 load flow analysis. cbco_module : :class:`~pomato.cbco.CBCOModule` The CBCO module provides the grid representation to the market model, based on the chosen configuration. Combines input data and the GridModel into a grid representation based on the chosen configuration (N-0, N-1, zonal, zonal CBCO, ntc, copper plate) and runs the redundancy removal algorithm needed for N-1 grid representation. grid_representation : dict The output of the cbco_module. A dictionary containing all information for the market model to account for the chosen network representation. market_model : :class:`~pomato.market_model.MarketModel` Module containing and managing the market model. This includes storing the necessary data, running and managing a julia process instance and initializing the result object inside ``data``. bokeh_plot : :class:`~pomato.visualization.BokehPlot` Enabling a geographic visualization of the market results through the library ``Bokeh``. This module processes the results and input data to create a static map plot containing mean line loadings or a dynamic/interactive plot for a timeseries. The latter is implemented through a bokeh server which requires some subprocess management. Parameters ---------- wdir : pathlib.Path, optional Working directory, defaulting to Path.cwd() if not specified, should be the root of the POMATO folder. options_file : str, optional Providing the name of an option file, usually located in the ``/profiles`` folder. If not provided, using default options as defined in tools. webapp : bool, optional Optional parameter to set logging settings when initializing POMATO as part of the included webapp. """ def __init__(self, options_file=None, webapp=False, wdir=None): self.wdir = wdir if wdir else Path.cwd() self.logger = _logging_setup(self.wdir, webapp) self.logger.info("Market Tool Initialized") tools.create_folder_structure(self.wdir, self.logger) # Core Attributes self.options = None self.initialize_options(options_file) self.data = DataManagement(self.options, self.wdir) self.grid = None self.cbco_module = None self.grid_representation = None self.market_model = None self.bokeh_plot = None def initialize_options(self, options_file): """Initialize options file. Parameters ---------- options_file : str, optional Providing the name of an option file, usually located in the ``/profiles`` folder. If not provided, using default options as defined in tools. """ try: with open(self.wdir.joinpath(options_file)) as ofile: self.options = json.load(ofile) opt_str = "Optimization Options:" + json.dumps(self.options, indent=2) + "\n" self.logger.info(opt_str) except FileNotFoundError: self.logger.warning( "No or invalid options file provided, using default options") self.options = tools.default_options() opt_str = "Optimization Options:" + json.dumps(self.options, indent=2) + "\n" self.logger.info(opt_str) except BaseException as unknown_exception: self.logger.exception("Error: %s", unknown_exception) def load_data(self, filename): """Load data into data_management module. The data attribute is initialized empty and explicitly filled with this method. When done reading and processing data, the grid model is also initialized. Parameters ---------- filename : str Providing the name of a data file, usually located in the ``/input_data`` folder. Excel files and matpower cases are supported. """ self.data.load_data(filename) self.grid = GridModel(self.data.nodes, self.data.lines) def init_market_model(self): """Initialize the market model. The Market model is initialized with the data object and a grid representation based on the chosen configuration. """ if not self.grid_representation: self.create_grid_representation() if not self.market_model: self.market_model = MarketModel(self.wdir, self.options) self.market_model.update_data(self.data, self.options, self.grid_representation) def update_market_model_data(self): """Update data within an instance of the market model. It is possible to change the data in the market mode and re-run without explicitly re-initializing the module. """ if not self.market_model: self.init_market_model() else: self.market_model.update_data(self.data, self.options, self.grid_representation) def initialize_market_results(self, result_folders): """Initionalizes market results from a list of folders. Parameters ---------- result_folders : list List of folders containing market resaults. """ if self.options["data"]["data_type"] == "ramses": for folder in result_folders: self.data.results[folder.name] = ENSResultProcessing( self.data, self.grid, folder) else: for folder in result_folders: self.data.results[folder.name] = ResultProcessing( self.data, self.grid, folder) def run_market_model(self): """Run the market model.""" if not self.market_model: self.init_market_model() self.market_model.run() if self.market_model.status == "solved": self.initialize_market_results(self.market_model.result_folders) else: self.logger.warning("Market Model not successfully run!") def _clear_data(self): """Reset DataManagement Class.""" self.logger.info("Resetting Data Object") self.data = DataManagement() def create_grid_representation(self): """Grid Representation as property. Creates grid representation to be used in the market model. """ self.cbco_module = CBCOModule(self.wdir, self.grid, self.data, self.options) self.cbco_module.create_grid_representation() self.grid_representation = self.cbco_module.grid_representation def init_bokeh_plot(self, name="default", bokeh_type="static", gen=None): """Initialize bokeh plot based on the dataset and a market result. Parameters ---------- name : str, optional Name defaults to 'default' is is used to identify the initialized market result in the plot itself and to name the folder within the ``data_temp/bokeh_files`` folder. bokeh_type : str, optional Specifies if a static or dynamic plot is generated. A dynamic plot requires to run a bokeh server, which is generally more involved. Defaults to static, which outputs a html version of the map with average loads. """ self.bokeh_plot = BokehPlot(self.wdir, bokeh_type=bokeh_type) if not self.data.results: # if results dict is empty self.logger.warning("No result available form market model!") else: self.bokeh_plot.create_static_plot(self.data.results)