def setup_module(m_args): """Run the simulation up to module E0 and save dict_values before and after evaluation""" if os.path.exists(TEST_OUTPUT_PATH): shutil.rmtree(TEST_OUTPUT_PATH, ignore_errors=True) user_input = A0.process_user_arguments() logging.debug("Accessing script: B0_data_input_json") dict_values = B0.load_json( user_input[PATH_INPUT_FILE], path_input_folder=user_input[PATH_INPUT_FOLDER], path_output_folder=user_input[PATH_OUTPUT_FOLDER], move_copy=False, ) logging.debug("Accessing script: C0_data_processing") C0.all(dict_values) logging.debug("Accessing script: D0_modelling_and_optimization") results_meta, results_main = D0.run_oemof(dict_values) with open(DICT_BEFORE, "wb") as handle: pickle.dump(dict_values, handle, protocol=pickle.HIGHEST_PROTOCOL) logging.debug("Accessing script: E0_evaluation") E0.evaluate_dict(dict_values, results_main, results_meta) with open(DICT_AFTER, "wb") as handle: pickle.dump(dict_values, handle, protocol=pickle.HIGHEST_PROTOCOL)
def test_get_name_or_names_of_in_or_output_bus_single(): bus = "bus" bus_with_suffix = C0.bus_suffix(bus) bus_name = C0.get_name_or_names_of_in_or_output_bus(bus) assert ( bus_name == bus_with_suffix ), f"A bus label with a string value is not appeded by the bus suffix."
def setup_class(m_args): """Run the simulation up to module E0 and prepare bus_data for E1""" if os.path.exists(TEST_OUTPUT_PATH): shutil.rmtree(TEST_OUTPUT_PATH, ignore_errors=True) logging.debug("Accessing script: A0_initialization") user_input = A0.process_user_arguments() A1.create_input_json(input_directory=os.path.join( user_input[PATH_INPUT_FOLDER], CSV_ELEMENTS)) logging.debug("Accessing script: B0_data_input_json") dict_values = B0.load_json( user_input[PATH_INPUT_FILE], path_input_folder=user_input[PATH_INPUT_FOLDER], path_output_folder=user_input[PATH_OUTPUT_FOLDER], move_copy=True, set_default_values=True, ) logging.debug("Accessing script: C0_data_processing") C0.all(dict_values) logging.debug("Accessing script: D0_modelling_and_optimization") results_meta, results_main = D0.run_oemof(dict_values) bus_data = {} # Store all information related to busses in bus_data for bus in dict_values[ENERGY_BUSSES]: # Read all energy flows from busses bus_data.update({bus: solph.views.node(results_main, bus)}) # Pickle dump bus data with open(BUS_DATA_DUMP, "wb") as handle: pickle.dump(bus_data, handle, protocol=pickle.HIGHEST_PROTOCOL)
def test_process_maximum_cap_constraint_subasset(): """For storages, the subassets have to be processes. This tests the procedure examplary.""" dict_values = { group: { asset: { subasset: { LABEL: asset, UNIT: unit, MAXIMUM_CAP: { VALUE: None }, } } } } C0.process_maximum_cap_constraint(dict_values, group, asset, subasset=subasset) assert ( dict_values[group][asset][subasset][MAXIMUM_CAP][VALUE] is None ), f"The function does not change the previously defined MAXIMUM_CAP." assert ( dict_values[group][asset][subasset][MAXIMUM_CAP][UNIT] == unit ), f"The maximumCap is in {dict_values[group][asset][subasset][MAXIMUM_CAP][UNIT]}, while the asset itself has unit {dict_values[group][asset][subasset][UNIT]}."
def test_add_busses_of_asset_depending_on_in_out_direction_single(): bus_names = ["bus_name_" + str(i) for i in range(1, 3)] asset_name = "asset" asset_label = "asset_label" energy_vector = "Electricity" dict_test = { ENERGY_BUSSES: {}, ENERGY_CONVERSION: { asset_name: { LABEL: asset_label, OUTFLOW_DIRECTION: bus_names[0], INFLOW_DIRECTION: bus_names[1], ENERGY_VECTOR: energy_vector, } }, } C0.add_busses_of_asset_depending_on_in_out_direction( dict_test, dict_test[ENERGY_CONVERSION][asset_name], asset_name) for k in bus_names: assert (k + BUS_SUFFIX in dict_test[ENERGY_BUSSES].keys() ), f"Bus {k+BUS_SUFFIX} is not added to the {ENERGY_BUSSES}." for bus in dict_test[ENERGY_BUSSES].keys(): assert (asset_name in dict_test[ENERGY_BUSSES][bus][ASSET_DICT].keys( )), f"Asset {asset_name} is not included in the asset list of {bus}." assert ( dict_test[ENERGY_BUSSES][bus][ASSET_DICT][asset_name] == asset_label ), f"The asset label of asset {asset_name} in the asset list of {bus} is of unexpected value."
def test_process_maximum_cap_constraint_maximumCap_is_0(): """The asset has no maximumCapacity, and the entry is translated into a unit-value pair.""" maxCap = 0 dict_values = { group: { asset: { UNIT: unit, INSTALLED_CAP: { VALUE: installed_cap }, MAXIMUM_CAP: { VALUE: maxCap }, } } } with pytest.warns(UserWarning): C0.process_maximum_cap_constraint(dict_values, group, asset, subasset=None) assert ( dict_values[group][asset][MAXIMUM_CAP][VALUE] is None ), f"The initial maximumCap defined by the end-user ({maxCap}) is overwritten by a different value ({dict_values[group][asset][MAXIMUM_CAP][VALUE]})."
def test_process_maximum_cap_constraint_maximumCap_is_int_smaller_than_installed_cap( ): """"The asset has a maximumCap < installedCap which is invalid and being ignored.""" maxCap = 10 dict_values = { group: { asset: { UNIT: unit, INSTALLED_CAP: { VALUE: installed_cap }, MAXIMUM_CAP: { VALUE: maxCap }, } } } with pytest.warns(UserWarning): C0.process_maximum_cap_constraint(dict_values, group, asset, subasset=None) assert ( dict_values[group][asset][MAXIMUM_CAP][VALUE] is None ), f"The invalid input is not ignored by defining maximumCap as None."
def test_update_bus(): bus_name = "bus_name" asset_name = "asset" asset_label = "asset_label" energy_vector = "Electricity" dict_test = { ENERGY_BUSSES: {}, ENERGY_CONVERSION: { asset_name: { LABEL: asset_label, OUTFLOW_DIRECTION: bus_name, ENERGY_VECTOR: energy_vector, } }, } bus_label = C0.bus_suffix(bus_name) C0.update_bus( dict_values=dict_test, bus=bus_name, asset_key=asset_name, asset_label=asset_label, energy_vector=energy_vector, ) assert (bus_label in dict_test[ENERGY_BUSSES] ), f"The {bus_label} is not added to the {ENERGY_BUSSES}." assert ( asset_name in dict_test[ENERGY_BUSSES][bus_label][ASSET_DICT] ), f"The asset {asset_name} is not added to the list of assets attached to the bus." assert ( dict_test[ENERGY_BUSSES][bus_label][ASSET_DICT][asset_name] == asset_label ), f"The asset {asset_name} is not added with its {LABEL} to the list of assets attached to the bus." assert ( dict_test[ENERGY_BUSSES][bus_label][ENERGY_VECTOR] == energy_vector ), f"The {ENERGY_VECTOR} of the added bus is not of the expected value."
def test_process_maximum_cap_constraint_group_is_ENERGY_PRODUCTION_non_dispatchable_asset( ): """The asset belongs to the energy production group, and is a non-dispatchable asset. As the maximumCap is used to define the maximum capacity of an asset, but used in oemof-solph to limit a flow, the value has to be translated.""" timeseries_peak = 0.8 group = ENERGY_PRODUCTION maxCap = 100 dict_values = { group: { asset: { LABEL: asset, UNIT: unit, INSTALLED_CAP: { VALUE: installed_cap }, MAXIMUM_CAP: { VALUE: maxCap }, FILENAME: "a_name", TIMESERIES_PEAK: { VALUE: timeseries_peak }, } } } C0.process_maximum_cap_constraint(dict_values, group, asset, subasset=None) assert ( dict_values[group][asset][MAXIMUM_CAP][VALUE] == maxCap * timeseries_peak ), f"The initial maximumCap defined by the end-user ({maxCap}) is overwritten by a different value ({dict_values[group][asset][MAXIMUM_CAP][VALUE]})."
def test_check_if_energy_carrier_is_defined_in_DEFAULT_WEIGHTS_ENERGY_CARRIERS_pass( ): # Function only needs to pass C0.check_if_energy_carrier_is_defined_in_DEFAULT_WEIGHTS_ENERGY_CARRIERS( "Electricity", "asset_group", "asset") assert ( 1 == 1 ), f"The energy carrier `Electricity` is not recognized to be defined in `DEFAULT_WEIGHTS_ENERGY_CARRIERS`."
def run_simulation(json_dict, **kwargs): r""" Starts MVS tool simulation from an input json file Parameters ----------- json_dict: dict json from http request Other Parameters ---------------- pdf_report: bool, optional Can generate an automatic pdf report of the simulation's results (True) or not (False) Default: False. display_output : str, optional Sets the level of displayed logging messages. Options: "debug", "info", "warning", "error". Default: "info". lp_file_output : bool, optional Specifies whether linear equation system generated is saved as lp file. Default: False. """ welcome_text = ( "\n \n Multi-Vector Simulation Tool (MVS) V" + version_num + " " + "\n Version: " + version_date + " " + '\n Part of the toolbox of H2020 project "E-LAND", ' + "Integrated multi-vector management system for Energy isLANDs" + "\n Coded at: Reiner Lemoine Institute (Berlin) " + "\n Contributors: Martha M. Hoffmann \n \n ") logging.info(welcome_text) logging.debug("Accessing script: B0_data_input_json") dict_values = data_input.convert_from_json_to_special_types(json_dict) print("") logging.debug("Accessing script: C0_data_processing") data_processing.all(dict_values) print("") logging.debug("Accessing script: D0_modelling_and_optimization") results_meta, results_main = modelling.run_oemof(dict_values) print("") logging.debug("Accessing script: E0_evaluation") evaluation.evaluate_dict(dict_values, results_main, results_meta) logging.debug("Convert results to json") epa_dict_values = data_parser.convert_mvs_params_to_epa(dict_values) output_processing.select_essential_results(epa_dict_values) json_values = output_processing.store_as_json(epa_dict_values) return json.loads(json_values)
def test_process_maximum_cap_constraint_maximumCap_is_None(): """The asset has a maximumCap==None, and a unit is added.""" dict_values = {group: {asset: {UNIT: unit, MAXIMUM_CAP: {VALUE: None}}}} C0.process_maximum_cap_constraint(dict_values, group, asset, subasset=None) assert ( dict_values[group][asset][MAXIMUM_CAP][VALUE] is None ), f"Eventhough there is no limit imposed to the asset capacity, its maximumCap is defined to be {dict_values[group][asset][MAXIMUM_CAP][VALUE]}." assert ( dict_values[group][asset][MAXIMUM_CAP][UNIT] == unit ), f"The maximumCap is in {dict_values[group][asset][MAXIMUM_CAP][UNIT]}, while the asset itself has unit {dict_values[group][asset][UNIT]}."
def test_evaluate_lifetime_costs(): settings = {EVALUATED_PERIOD: {VALUE: 10}} economic_data = { PROJECT_DURATION: { VALUE: 20 }, DISCOUNTFACTOR: { VALUE: 0.1 }, TAX: { VALUE: 0 }, CRF: { VALUE: 0.1 }, ANNUITY_FACTOR: { VALUE: 7 }, } dict_asset = { SPECIFIC_COSTS_OM: { VALUE: 5, UNIT: "unit" }, SPECIFIC_COSTS: { VALUE: 100, UNIT: "unit" }, DISPATCH_PRICE: { VALUE: 1, UNIT: "unit" }, LIFETIME: { VALUE: 10 }, UNIT: UNIT, AGE_INSTALLED: { VALUE: 0 }, } C0.evaluate_lifetime_costs(settings, economic_data, dict_asset) # Note: Only the relevant keys are tested here. The valid calculation of the costs is tested with test_benchmark_KPI.py, Test_Economic_KPI.test_benchmark_Economic_KPI_C2_E2() for k in [ LIFETIME_SPECIFIC_COST, LIFETIME_SPECIFIC_COST_OM, ANNUITY_SPECIFIC_INVESTMENT_AND_OM, SIMULATION_ANNUITY, LIFETIME_PRICE_DISPATCH, SPECIFIC_REPLACEMENT_COSTS_INSTALLED, SPECIFIC_REPLACEMENT_COSTS_OPTIMIZED, ]: assert k in dict_asset, f"Function does not add {k} to the asset dictionary."
def test_evaluate_lifetime_costs_adds_all_parameters(): C0.evaluate_lifetime_costs(settings, economic_data, dict_asset) for k in ( LIFETIME_SPECIFIC_COST, ANNUITY_SPECIFIC_INVESTMENT_AND_OM, LIFETIME_SPECIFIC_COST_OM, LIFETIME_PRICE_DISPATCH, SIMULATION_ANNUITY, SPECIFIC_REPLACEMENT_COSTS_OPTIMIZED, SPECIFIC_REPLACEMENT_COSTS_INSTALLED, ): assert (k in dict_asset.keys() ), f"Function does not add {k} to the asset dictionary."
def test_process_maximum_cap_constraint_maximumCap_undefined(): """If no maximum cap is defined previously, it is defined as none.""" dict_values = {group: {asset: {UNIT: unit}}} C0.process_maximum_cap_constraint(dict_values, group, asset, subasset=None) assert ( MAXIMUM_CAP in dict_values[group][asset] ), f"The function does not add a MAXIMUM_CAP to the asset dictionary." assert ( dict_values[group][asset][MAXIMUM_CAP][VALUE] is None ), f"Eventhough there is no limit imposed to the asset capacity, its maximumCap is defined to be {dict_values[group][asset][MAXIMUM_CAP][VALUE]}." assert ( dict_values[group][asset][MAXIMUM_CAP][UNIT] == unit ), f"The maximumCap is in {dict_values[group][asset][MAXIMUM_CAP][UNIT]}, while the asset itself has unit {dict_values[group][asset][UNIT]}."
def test_add_economic_parameters(): economic_parameters = { PROJECT_DURATION: { VALUE: 20 }, DISCOUNTFACTOR: { VALUE: 0.15 }, } C0.add_economic_parameters(economic_parameters) # the actual value of the annuity factor should have been checked in C2 for k in (ANNUITY_FACTOR, CRF): assert (k in economic_parameters.keys() ), f"Function does not add {k} to the economic parameters."
def test_define_transformer_for_peak_demand_pricing(): dict_test = { ENERGY_CONVERSION: {}, ENERGY_PROVIDERS: { "dso": { LABEL: "a_label", INFLOW_DIRECTION: "a_direction", OUTFLOW_DIRECTION: "b_direction", PEAK_DEMAND_PRICING: { VALUE: 60 }, UNIT: "unit", ENERGY_VECTOR: "a_vector", } }, } dict_test_dso = dict_test[ENERGY_PROVIDERS]["dso"].copy() transformer_name = "a_name" timeseries_availability = pd.Series() C0.define_transformer_for_peak_demand_pricing(dict_test, dict_test_dso, transformer_name, timeseries_availability) assert transformer_name in dict_test[ENERGY_CONVERSION] for k in [ LABEL, OPTIMIZE_CAP, INSTALLED_CAP, INFLOW_DIRECTION, OUTFLOW_DIRECTION, AVAILABILITY_DISPATCH, DISPATCH_PRICE, SPECIFIC_COSTS, DEVELOPMENT_COSTS, SPECIFIC_COSTS_OM, OEMOF_ASSET_TYPE, INPUT_BUS_NAME, OUTPUT_BUS_NAME, EFFICIENCY, ENERGY_VECTOR, ]: assert ( k in dict_test[ENERGY_CONVERSION][transformer_name] ), f"Function does not add {k} to the asset dictionary of the {transformer_name}." assert ( dict_test[ENERGY_CONVERSION][transformer_name][SPECIFIC_COSTS_OM] [VALUE] == dict_test[ENERGY_PROVIDERS]["dso"][PEAK_DEMAND_PRICING] [VALUE] ), f"The {SPECIFIC_COSTS_OM} of the newly defined {transformer_name} is not equal to the {PEAK_DEMAND_PRICING} of the energy provider it is defined from."
def test_define_availability_of_peak_demand_pricing_assets_yearly(): dict_availability_timeseries = C0.define_availability_of_peak_demand_pricing_assets( dict_test_avilability, 1, 12) assert ( len(dict_availability_timeseries) == 1 ), f"Function does not create a single availability_timeseries for the whole year." assert ( dict_availability_timeseries[1].values.sum() == 8760 ), f"Availablity of a single dict_availability_timeseries is not ensured for every hour of the year."
def test_apply_function_to_single_or_list_apply_to_single(): def multiply(parameter): parameter_processed = 2 * parameter return parameter_processed parameter = 1 parameter_processed = C0.apply_function_to_single_or_list( multiply, parameter) assert parameter_processed == 2, f"The multiplication with a single value fails."
def test_apply_function_to_single_or_list_apply_to_list(): def multiply(parameter): parameter_processed = 2 * parameter return parameter_processed parameter = [1, 1] parameter_processed = C0.apply_function_to_single_or_list( multiply, parameter) assert parameter_processed == [2, 2], f"The multiplication with a list fails."
def run_parts(margs): if os.path.exists(TEST_OUTPUT_PATH): shutil.rmtree(TEST_OUTPUT_PATH, ignore_errors=True) user_input = A0.process_user_arguments() logging.debug("Accessing script: B0_data_input_json") dict_values = B0.load_json( user_input[PATH_INPUT_FILE], path_input_folder=user_input[PATH_INPUT_FOLDER], path_output_folder=user_input[PATH_OUTPUT_FOLDER], move_copy=False, ) logging.debug("Accessing script: C0_data_processing") C0.all(dict_values) logging.debug("Run parts of D0_modelling_and_optimization") model, dict_model = D0.model_building.initialize(dict_values) model = D0.model_building.adding_assets_to_energysystem_model( dict_values, dict_model, model) return dict_values, model, dict_model
def test_define_availability_of_peak_demand_pricing_assets_quarterly(): dict_availability_timeseries = C0.define_availability_of_peak_demand_pricing_assets( dict_test_avilability, 4, 3) assert ( len(dict_availability_timeseries) == 4 ), f"Function does not create 4 individual availability_timeseries for the whole year." total = 0 for key in dict_availability_timeseries: total += dict_availability_timeseries[key].values.sum() assert ( total == 8760 ), f"Availablity of all 12 availability_timeseries does not insure availability every hour of the year."
def test_process_maximum_cap_constraint_maximumCap_is_float(): """The asset has a maximumCap of float, and a unit is added""" maxCap = 100.1 dict_values = { group: { asset: { UNIT: unit, INSTALLED_CAP: { VALUE: installed_cap }, MAXIMUM_CAP: { VALUE: maxCap }, } } } C0.process_maximum_cap_constraint(dict_values, group, asset, subasset=None) assert ( dict_values[group][asset][MAXIMUM_CAP][VALUE] == maxCap ), f"The initial maximumCap defined by the end-user ({maxCap}) is overwritten by a different value ({dict_values[group][asset][MAXIMUM_CAP][VALUE]})." assert ( dict_values[group][asset][MAXIMUM_CAP][UNIT] == unit ), f"The maximumCap is in {dict_values[group][asset][MAXIMUM_CAP][UNIT]}, while the asset itself has unit {dict_values[group][asset][UNIT]}."
def test_process_maximum_cap_constraint_group_is_ENERGY_PRODUCTION_fuel_source( ): """The asset belongs to the energy production group, but is a dispatchable fuel source. The maximumCap is processed as usual.""" group = ENERGY_PRODUCTION maxCap = 100 dict_values = { group: { asset: { LABEL: asset, UNIT: unit, INSTALLED_CAP: { VALUE: installed_cap }, MAXIMUM_CAP: { VALUE: maxCap }, FILENAME: None, } } } C0.process_maximum_cap_constraint(dict_values, group, asset, subasset=None) assert ( dict_values[group][asset][MAXIMUM_CAP][VALUE] == maxCap ), f"The initial maximumCap defined by the end-user ({maxCap}) is overwritten by a different value ({dict_values[group][asset][MAXIMUM_CAP][VALUE]})."
def test_define_availability_of_peak_demand_pricing_assets_monthly(): dict_availability_timeseries = C0.define_availability_of_peak_demand_pricing_assets( dict_test_avilability, 12, 1) assert ( len(dict_availability_timeseries) == 12 ), f"Function does not create 12 individual availability_timeseries for the whole year." assert ( dict_availability_timeseries[1].values.sum() == 31 * 24 ), f"Availability timeseries that is supposed to be 1 for January alone has an unexpected number of available hours." total = 0 for key in dict_availability_timeseries: total += dict_availability_timeseries[key].values.sum() assert ( total == 8760 ), f"Availablity of all 12 availability_timeseries does not insure availability every hour of the year."
def test_check_if_energy_carrier_is_defined_in_DEFAULT_WEIGHTS_ENERGY_CARRIERS_fail( ): with pytest.raises(C0.UnknownEnergyCarrier): C0.check_if_energy_carrier_is_defined_in_DEFAULT_WEIGHTS_ENERGY_CARRIERS( "Bio-Diesel", "asset_group", "asset" ), f"The energy carrier `Bio-Diesel` is recognized in the `DEFAULT_WEIGHTS_ENERGY_CARRIERS`, eventhough it should not be defined."
def test_determine_months_in_a_peak_demand_pricing_period_not_valid(): with pytest.raises(C0.InvalidPeakDemandPricingPeriods): C0.determine_months_in_a_peak_demand_pricing_period( 5, 365 ), f"No C0.InvalidPeakDemandPricingPeriods is raised eventhough an invalid number of pricing periods is requested."
def test_determine_months_in_a_peak_demand_pricing_period_valid(): months_in_a_period = C0.determine_months_in_a_peak_demand_pricing_period( 4, 365) assert ( months_in_a_period == 3 ), f"The duration, ie. months of the peak demand pricing periods, are calculated incorrectly."
def main(**kwargs): r""" Starts MVS tool simulations. Other Parameters ---------------- overwrite : bool, optional Determines whether to replace existing results in `path_output_folder` with the results of the current simulation (True) or not (False). Default: False. pdf_report: bool, optional Can generate an automatic pdf report of the simulation's results (True) or not (False) Default: False. input_type : str, optional Defines whether the input is taken from the `mvs_config.json` file ("json") or from csv files ('csv') located within <path_input_folder>/csv_elements/. Default: 'json'. path_input_folder : str, optional The path to the directory where the input CSVs/JSON files are located. Default: 'inputs/'. path_output_folder : str, optional The path to the directory where the results of the simulation such as the plots, time series, results JSON files are saved by MVS E-Lands. Default: 'MVS_outputs/' display_output : str, optional Sets the level of displayed logging messages. Options: "debug", "info", "warning", "error". Default: "info". lp_file_output : bool, optional Specifies whether linear equation system generated is saved as lp file. Default: False. """ welcome_text = ( "\n \n Multi-Vector Simulation Tool (MVS) V" + version_num + " " + "\n Version: " + version_date + " " + '\n Part of the toolbox of H2020 project "E-LAND", ' + "Integrated multi-vector management system for Energy isLANDs" + "\n Coded at: Reiner Lemoine Institute (Berlin) " + "\n Contributors: Martha M. Hoffmann \n \n ") logging.debug("Accessing script: A0_initialization") user_input = A0.process_user_arguments(welcome_text=welcome_text, **kwargs) # Read all inputs # print("") # # todo: is user input completely used? # dict_values = data_input.load_json(user_input[PATH_INPUT_FILE ]) move_copy_config_file = False if user_input[INPUT_TYPE] == CSV_EXT: logging.debug("Accessing script: A1_csv_to_json") move_copy_config_file = True A1.create_input_json(input_directory=os.path.join( user_input[PATH_INPUT_FOLDER], CSV_ELEMENTS)) logging.debug("Accessing script: B0_data_input_json") dict_values = B0.load_json( user_input[PATH_INPUT_FILE], path_input_folder=user_input[PATH_INPUT_FOLDER], path_output_folder=user_input[PATH_OUTPUT_FOLDER], move_copy=move_copy_config_file, set_default_values=True, ) F0.store_as_json( dict_values, dict_values[SIMULATION_SETTINGS][PATH_OUTPUT_FOLDER_INPUTS], MVS_CONFIG, ) print("") logging.debug("Accessing script: C0_data_processing") C0.all(dict_values) F0.store_as_json( dict_values, dict_values[SIMULATION_SETTINGS][PATH_OUTPUT_FOLDER], JSON_PROCESSED, ) if "path_pdf_report" in user_input or "path_png_figs" in user_input: save_energy_system_graph = True else: save_energy_system_graph = False print("") logging.debug("Accessing script: D0_modelling_and_optimization") results_meta, results_main = D0.run_oemof( dict_values, save_energy_system_graph=save_energy_system_graph, ) print("") logging.debug("Accessing script: E0_evaluation") E0.evaluate_dict(dict_values, results_main, results_meta) logging.debug("Accessing script: F0_outputs") F0.evaluate_dict( dict_values, path_pdf_report=user_input.get("path_pdf_report", None), path_png_figs=user_input.get("path_png_figs", None), ) return 1
def test_get_name_or_names_of_in_or_output_bus_list(): bus = ["bus1", "bus2"] bus_with_suffix = [C0.bus_suffix(bus[0]), C0.bus_suffix(bus[1])] bus_name = C0.get_name_or_names_of_in_or_output_bus(bus) assert (bus_name == bus_with_suffix ), f"A list of bus names is not appended by the bus suffix."