def run(interface, port, setup_module_name, settings_file, slowdown, seed, paused, pause_after, repl, export, export_path, reset_on_finish, reset_on_finish_wait, exit_on_finish, exit_on_finish_wait, enable_bc, enable_bm, **config_params): try: if settings_file is not None: simulation_settings, advanced_settings = read_settings_from_file( settings_file) update_advanced_settings(advanced_settings) simulation_config = SimulationConfig(**simulation_settings) else: simulation_config = SimulationConfig(**config_params) api_url = "http://{}:{}/api".format(interface, port) ConstSettings.BalancingSettings.ENABLE_BALANCING_MARKET = enable_bm simulation = Simulation(setup_module_name=setup_module_name, simulation_config=simulation_config, slowdown=slowdown, seed=seed, paused=paused, pause_after=pause_after, use_repl=repl, export=export, export_path=export_path, reset_on_finish=reset_on_finish, reset_on_finish_wait=reset_on_finish_wait, exit_on_finish=exit_on_finish, exit_on_finish_wait=exit_on_finish_wait, api_url=api_url, redis_job_id=None, use_bc=enable_bc) except D3AException as ex: raise click.BadOptionUsage(ex.args[0]) start_web(interface, port, simulation) simulation.run()
def run(setup_module_name, settings_file, duration, slot_length, tick_length, market_count, cloud_coverage, compare_alt_pricing, enable_external_connection, start_date, pause_at, slot_length_realtime, **kwargs): # Force the multiprocessing start method to be 'fork' on macOS. if platform.system() == 'Darwin': multiprocessing.set_start_method('fork') try: if settings_file is not None: simulation_settings, advanced_settings = read_settings_from_file( settings_file) update_advanced_settings(advanced_settings) validate_global_settings(simulation_settings) simulation_settings["external_connection_enabled"] = False simulation_config = SimulationConfig(**simulation_settings) else: global_settings = { "sim_duration": duration, "slot_length": slot_length, "tick_length": tick_length, "cloud_coverage": cloud_coverage, "market_count": market_count } validate_global_settings(global_settings) simulation_config = \ SimulationConfig(duration, slot_length, tick_length, market_count, cloud_coverage, start_date=start_date, external_connection_enabled=enable_external_connection) if compare_alt_pricing is True: ConstSettings.IAASettings.AlternativePricing.COMPARE_PRICING_SCHEMES = True # we need the seconds in the export dir name kwargs["export_subdir"] = DateTime.now( tz=TIME_ZONE).format(f"{DATE_TIME_FORMAT}:ss") processes = [] for pricing_scheme in range(0, 4): kwargs["pricing_scheme"] = pricing_scheme p = Process(target=run_simulation, args=(setup_module_name, simulation_config, None, None, None, slot_length_realtime, kwargs)) p.start() processes.append(p) for p in processes: p.join() else: if pause_at is not None: kwargs["pause_after"] = convert_str_to_pause_after_interval( start_date, pause_at) run_simulation(setup_module_name, simulation_config, None, None, None, slot_length_realtime, kwargs) except D3AException as ex: raise click.BadOptionUsage(ex.args[0])
def start(scenario, settings): logging.getLogger().setLevel(logging.ERROR) interface = environ.get('WORKER_INTERFACE', "0.0.0.0") port = int(environ.get('WORKER_PORT', 5000)) api_host = environ.get('WORKER_HOST', interface) api_url = "http://{}:{}/api".format(api_host, port) job = get_current_job() job.meta['api_url'] = api_url job.save_meta() if settings is None: settings = {} advanced_settings = settings.get('advanced_settings', None) if advanced_settings is not None: update_advanced_settings(ast.literal_eval(advanced_settings)) config = SimulationConfig( duration=pendulum.duration(days=1 if 'duration' not in settings else settings['duration'].days), slot_length=pendulum.duration( seconds=15 * 60 if 'slot_length' not in settings else settings['slot_length'].seconds), tick_length=pendulum.duration( seconds=15 if 'tick_length' not in settings else settings['tick_length'].seconds), market_count=settings.get('market_count', 1), cloud_coverage=settings.get( 'cloud_coverage', ConstSettings.PVSettings.DEFAULT_POWER_PROFILE), pv_user_profile=settings.get('pv_user_profile', None), market_maker_rate=settings.get( 'market_maker_rate', str(ConstSettings.GeneralSettings.DEFAULT_MARKET_MAKER_RATE)), iaa_fee=settings.get('iaa_fee', ConstSettings.IAASettings.FEE_PERCENTAGE)) if scenario is None: scenario_name = "default" elif scenario in available_simulation_scenarios: scenario_name = scenario else: scenario_name = 'json_arg' config.area = scenario simulation = Simulation(scenario_name, config, slowdown=settings.get('slowdown', 0), exit_on_finish=True, exit_on_finish_wait=pendulum.duration(seconds=10), api_url=api_url, redis_job_id=job.id) start_web(interface, port, simulation) simulation.run()
def test_parse_settings_file(self): simulation_settings, advanced_settings = read_settings_from_file( os.path.join(d3a_path, "setup", "d3a-settings.json")) update_advanced_settings(advanced_settings) simulation_config = SimulationConfig(**simulation_settings) assert simulation_config.__getattribute__( "sim_duration") == IntervalType('H:M')("24h") try: for setting in advanced_settings.keys(): getattr(ConstSettings, setting) except AttributeError: self.fail( "The settings file is not consistent with the selection of variables in " "const.py")
def run_sim(context, scenario, total_duration, slot_length, tick_length, iaa_fee, market_count): root_logger = logging.getLogger() root_logger.setLevel(logging.CRITICAL) simulation_config = SimulationConfig(duration(hours=int(total_duration)), duration(minutes=int(slot_length)), duration(seconds=int(tick_length)), market_count=int(market_count), cloud_coverage=0, market_maker_rate=30, iaa_fee=int(iaa_fee)) slowdown = 0 seed = 0 paused = False pause_after = duration() repl = False export = False export_path = None reset_on_finish = False reset_on_finish_wait = duration() exit_on_finish = True exit_on_finish_wait = duration() api_url = "http://localhost:5000/api" context.simulation = Simulation(scenario, simulation_config, slowdown, seed, paused, pause_after, repl, export, export_path, reset_on_finish, reset_on_finish_wait, exit_on_finish, exit_on_finish_wait, api_url) context.simulation.run()
def run_sim_with_config_setting(context, cloud_coverage, iaa_fee, scenario): root_logger = logging.getLogger() root_logger.setLevel(logging.CRITICAL) simulation_config = SimulationConfig( duration(hours=int(24)), duration(minutes=int(60)), duration(seconds=int(60)), market_count=4, cloud_coverage=int(cloud_coverage), market_maker_rate=context._market_maker_rate, iaa_fee=int(iaa_fee)) slowdown = 0 seed = 0 paused = False pause_after = duration() repl = False export = False export_path = None reset_on_finish = False reset_on_finish_wait = duration() exit_on_finish = True exit_on_finish_wait = duration() api_url = "http://localhost:5000/api" context.simulation = Simulation(scenario, simulation_config, slowdown, seed, paused, pause_after, repl, export, export_path, reset_on_finish, reset_on_finish_wait, exit_on_finish, exit_on_finish_wait, api_url) context.simulation.run()
def create_config(settings={}): config_settings = { "start_date": instance(datetime.combine(settings.get('start_date'), datetime.min.time())) if 'start_date' in settings else GlobalConfig.start_date, "sim_duration": duration(days=settings['duration'].days) if 'duration' in settings else GlobalConfig.sim_duration, "slot_length": duration(seconds=settings['slot_length'].seconds) if 'slot_length' in settings else GlobalConfig.slot_length, "tick_length": duration(seconds=settings['tick_length'].seconds) if 'tick_length' in settings else GlobalConfig.tick_length, "market_maker_rate": settings.get('market_maker_rate', str(ConstSettings.GeneralSettings.DEFAULT_MARKET_MAKER_RATE)), "market_count": settings.get('market_count', GlobalConfig.market_count), "cloud_coverage": settings.get('cloud_coverage', GlobalConfig.cloud_coverage), "pv_user_profile": settings.get('pv_user_profile', None), "max_panel_power_W": settings.get('max_panel_power_W', ConstSettings.PVSettings.MAX_PANEL_OUTPUT_W), "grid_fee_type": settings.get('grid_fee_type', GlobalConfig.grid_fee_type), "external_connection_enabled": settings.get('external_connection_enabled', False), "aggregator_device_mapping": None } return SimulationConfig(**config_settings)
def run_sim_with_config_setting(context, cloud_coverage, iaa_fee, scenario): root_logger = logging.getLogger() root_logger.setLevel(logging.CRITICAL) simulation_config = SimulationConfig(duration(hours=int(24)), duration(minutes=int(60)), duration(seconds=int(60)), market_count=4, cloud_coverage=int(cloud_coverage), iaa_fee=int(iaa_fee)) slowdown = 0 seed = 0 paused = False pause_after = duration() repl = False no_export = True export_path = None export_subdir = None context.simulation = Simulation( scenario, simulation_config, None, slowdown, seed, paused, pause_after, repl, no_export, export_path, export_subdir, ) context.simulation.run()
def test_results_not_send_via_kafka_if_started_from_cli(): redis_job_id = "1234" simulation_config = SimulationConfig(duration(hours=int(12)), duration(minutes=int(60)), duration(seconds=int(60)), market_count=1, cloud_coverage=0, market_maker_rate=30, start_date=today(tz=TIME_ZONE), external_connection_enabled=False) simulation = Simulation("default_2a", simulation_config, None, 0, False, duration(), False, True, None, None, redis_job_id, False) simulation.endpoint_buffer = MagicMock(spec=SimulationEndpointBuffer) results_mapping = ResultsHandler().results_mapping simulation.endpoint_buffer.results_handler = MagicMock( spec=ResultsHandler) simulation.kafka_connection = MagicMock(spec=KafkaConnection) simulation.endpoint_buffer.results_handler.all_ui_results = { k: {} for k in results_mapping } simulation._update_and_send_results() simulation.endpoint_buffer.prepare_results_for_publish.assert_called_once( ) simulation.kafka_connection.publish.assert_called_once()
def config(self): return SimulationConfig( duration=Duration(hours=24), market_count=4, slot_length=Duration(minutes=15), tick_length=Duration(seconds=15), cloud_coverage=ConstSettings.PVSettings.DEFAULT_POWER_PROFILE, market_maker_rate=ConstSettings.GeneralSettings. DEFAULT_MARKET_MAKER_RATE, iaa_fee=ConstSettings.IAASettings.FEE_PERCENTAGE)
def create_sim_object(context, scenario): simulation_config = SimulationConfig(duration(hours=int(24)), duration(minutes=int(15)), duration(seconds=int(30)), market_count=4, cloud_coverage=0, market_maker_rate=30, iaa_fee=5) context.simulation = Simulation(scenario, simulation_config, 0, 0, False, duration(), False, False, None, False, duration(), True, duration(), None, "1234")
def config(self): configuration = SimulationConfig( sim_duration=Duration(hours=24), market_count=4, slot_length=Duration(minutes=15), tick_length=Duration(seconds=15), cloud_coverage=ConstSettings.PVSettings.DEFAULT_POWER_PROFILE, market_maker_rate=ConstSettings.GeneralSettings. DEFAULT_MARKET_MAKER_RATE, external_connection_enabled=False) change_global_config(**configuration.__dict__) return configuration
def create_sim_object(context, scenario): simulation_config = SimulationConfig(duration(hours=int(12)), duration(minutes=int(60)), duration(seconds=int(60)), market_count=1, cloud_coverage=0, market_maker_rate=30, start_date=today(tz=TIME_ZONE), external_connection_enabled=False) context.simulation = Simulation(scenario, simulation_config, None, 0, False, duration(), False, True, None, None, "1234", False)
def run_sim(context, scenario, total_duration, slot_length, tick_length, market_count): root_logger = logging.getLogger() root_logger.setLevel(logging.ERROR) simulation_config = SimulationConfig(duration(hours=int(total_duration)), duration(minutes=int(slot_length)), duration(seconds=int(tick_length)), market_count=int(market_count), cloud_coverage=0, market_maker_rate=30, external_connection_enabled=False) seed = 0 paused = False pause_after = duration() repl = False export_subdir = None context.export_path = os.path.join(context.simdir, scenario) os.makedirs(context.export_path, exist_ok=True) try: context.simulation = Simulation( scenario, simulation_config, None, seed, paused, pause_after, repl, context.no_export, context.export_path, export_subdir, ) context.simulation.run() except Exception as er: if context.raise_exception_when_running_sim: root_logger.critical( f"Error reported when running the simulation: {er}") root_logger.critical(f"Traceback: {traceback.format_exc()}") raise Exception(er) else: context.sim_error = er
def pv_profile_scenario(context): predefined_pv_scenario = { "name": "Grid", "children": [{ "name": "Commercial Energy Producer", "type": "CommercialProducer", "energy_rate": 15.5 }, { "name": "House 1", "children": [{ "name": "H1 Load", "type": "LoadHours", "avg_power_W": 400, "hrs_per_day": 24 }, { "name": "H1 PV", "type": "PVProfile", "panel_count": 1, "power_profile": context._device_profile }] }, { "name": "House 2", "children": [{ "name": "H2 Storage", "type": "Storage", "initial_capacity_kWh": 5, "battery_capacity_kWh": 12.5, }] }] } context._settings = SimulationConfig(tick_length=duration(seconds=15), slot_length=duration(minutes=15), duration=duration(hours=24), market_count=4, cloud_coverage=0, market_maker_rate=30, iaa_fee=5) context._settings.area = predefined_pv_scenario
def run_sim(context, scenario, total_duration, slot_length, tick_length, market_count): root_logger = logging.getLogger() root_logger.setLevel(logging.CRITICAL) simulation_config = SimulationConfig(duration(hours=int(total_duration)), duration(minutes=int(slot_length)), duration(seconds=int(tick_length)), market_count=int(market_count), cloud_coverage=0, market_maker_rate=30, external_connection_enabled=False) slowdown = 0 seed = 0 paused = False pause_after = duration() repl = False no_export = True export_path = None export_subdir = None try: context.simulation = Simulation( scenario, simulation_config, None, slowdown, seed, paused, pause_after, repl, no_export, export_path, export_subdir, ) context.simulation.run() except Exception as er: root_logger.critical( f"Error reported when running the simulation: {er}") context.sim_error = er
def run_sim_multiday(context, scenario, start_date, total_duration, slot_length, tick_length): root_logger = logging.getLogger() root_logger.setLevel(logging.CRITICAL) if start_date == "None": start_date = today(tz=TIME_ZONE) else: start_date = from_format(start_date, DATE_FORMAT) simulation_config = SimulationConfig(duration(hours=int(total_duration)), duration(minutes=int(slot_length)), duration(seconds=int(tick_length)), market_count=1, cloud_coverage=0, market_maker_rate=30, iaa_fee=1, start_date=start_date) slowdown = 0 seed = 0 paused = False pause_after = duration() repl = False no_export = True export_path = None export_subdir = None context.simulation = Simulation( scenario, simulation_config, None, slowdown, seed, paused, pause_after, repl, no_export, export_path, export_subdir, ) context.simulation.run()
def load_profile_scenario(context): predefined_load_scenario = { "name": "Grid", "children": [{ "name": "Commercial Energy Producer", "type": "CommercialProducer", "energy_rate": 15.5 }, { "name": "House 1", "children": [{ "name": "H1 Load", "type": "LoadProfile", "daily_load_profile": context._device_profile }, { "name": "H1 PV", "type": "PV", "panel_count": 3 }] }, { "name": "House 2", "children": [{ "name": "H2 Storage", "type": "Storage", "battery_capacity_kWh": 12.5, }] }] } context._settings = SimulationConfig(tick_length=duration(seconds=60), slot_length=duration(minutes=60), sim_duration=duration(hours=24), market_count=4, cloud_coverage=0, market_maker_rate=30, iaa_fee=5) context._settings.area = predefined_load_scenario
def setUp(self): self.config = SimulationConfig( sim_duration=duration(hours=12), slot_length=duration(minutes=15), tick_length=duration(seconds=15), market_count=1, cloud_coverage=0, external_connection_enabled=False ) self.live_events = LiveEvents(self.config) self.strategy_load = LoadHoursStrategy( avg_power_W=123, hrs_per_day=3, hrs_of_day=[2, 3, 4, 5], fit_to_limit=False, energy_rate_increase_per_update=2, update_interval=5, initial_buying_rate=11, final_buying_rate=31) self.strategy_pv = PVStrategy( panel_count=3, initial_selling_rate=34, final_selling_rate=12, fit_to_limit=False, update_interval=6, energy_rate_decrease_per_update=4, max_panel_power_W=432) self.strategy_battery = StorageStrategy( initial_soc=11, min_allowed_soc=10, battery_capacity_kWh=6, max_abs_battery_power_kW=123, cap_price_strategy=False, initial_selling_rate=32, final_selling_rate=20, initial_buying_rate=10, final_buying_rate=19, fit_to_limit=False, energy_rate_increase_per_update=5, energy_rate_decrease_per_update=8, update_interval=9 ) self.area1 = Area("load", None, None, self.strategy_load, SwitchableAppliance(), self.config, None, grid_fee_percentage=0) self.area2 = Area("pv", None, None, self.strategy_pv, PVAppliance(), self.config, None, grid_fee_percentage=0) self.area3 = Area("storage", None, None, self.strategy_battery, SwitchableAppliance(), self.config, None, grid_fee_percentage=0) self.area_house1 = Area("House 1", children=[self.area1, self.area2], config=self.config) self.area_house2 = Area("House 2", children=[self.area3], config=self.config) self.area_grid = Area("Grid", children=[self.area_house1, self.area_house2], config=self.config)
from d3a.models.strategy import BaseStrategy from d3a.d3a_core.util import TaggedLogWrapper from d3a.models.const import ConstSettings from d3a.d3a_core.device_registry import DeviceRegistry from d3a.constants import TIME_FORMAT from d3a.models.area.stats import AreaStats from d3a.models.area.event_dispatcher import AreaDispatcher from d3a.models.area.markets import AreaMarkets log = getLogger(__name__) DEFAULT_CONFIG = SimulationConfig( duration=duration(hours=24), market_count=1, slot_length=duration(minutes=15), tick_length=duration(seconds=1), cloud_coverage=ConstSettings.PVSettings.DEFAULT_POWER_PROFILE, market_maker_rate=str( ConstSettings.GeneralSettings.DEFAULT_MARKET_MAKER_RATE), iaa_fee=ConstSettings.IAASettings.FEE_PERCENTAGE) class Area: _area_id_counter = 1 def __init__(self, name: str = None, children: List["Area"] = None, strategy: BaseStrategy = None, appliance: BaseAppliance = None, config: SimulationConfig = None,
from d3a.constants import TIME_FORMAT from d3a.models.area.stats import AreaStats from d3a.models.area.event_dispatcher import DispatcherFactory from d3a.models.area.markets import AreaMarkets from d3a.models.area.events import Events from d3a_interface.constants_limits import GlobalConfig from d3a.models.area.redis_external_connection import RedisAreaExternalConnection import d3a.constants log = getLogger(__name__) DEFAULT_CONFIG = SimulationConfig( sim_duration=duration(hours=24), market_count=1, slot_length=duration(minutes=15), tick_length=duration(seconds=1), cloud_coverage=ConstSettings.PVSettings.DEFAULT_POWER_PROFILE, iaa_fee=ConstSettings.IAASettings.FEE_PERCENTAGE, iaa_fee_const=ConstSettings.IAASettings.FEE_CONSTANT, start_date=today(tz=TIME_ZONE), max_panel_power_W=ConstSettings.PVSettings.MAX_PANEL_OUTPUT_W) class Area: def __init__(self, name: str = None, children: List["Area"] = None, uuid: str = None, strategy: BaseStrategy = None, appliance: BaseAppliance = None, config: SimulationConfig = None, budget_keeper=None,
def launch_simulation_from_rq_job(scenario, settings, events, aggregator_device_mapping, saved_state, job_id): logging.getLogger().setLevel(logging.ERROR) scenario = decompress_and_decode_queued_strings(scenario) if "collaboration_uuid" in scenario: d3a.constants.COLLABORATION_ID = scenario.pop("collaboration_uuid") d3a.constants.EXTERNAL_CONNECTION_WEB = True GlobalConfig.IS_CANARY_NETWORK = scenario.pop("is_canary_network", False) d3a.constants.RUN_IN_REALTIME = GlobalConfig.IS_CANARY_NETWORK saved_state = decompress_and_decode_queued_strings(saved_state) log.error(f"Starting simulation with job_id: {job_id}") try: if settings is None: settings = {} else: settings = { k: v for k, v in settings.items() if v is not None and v != "None" } advanced_settings = settings.get('advanced_settings', None) if advanced_settings is not None: update_advanced_settings(ast.literal_eval(advanced_settings)) aggregator_device_mapping = json.loads(aggregator_device_mapping) if events is not None: events = ast.literal_eval(events) config_settings = { "start_date": instance( datetime.combine(settings.get('start_date'), datetime.min.time())) if 'start_date' in settings else GlobalConfig.start_date, "sim_duration": duration(days=settings['duration'].days) if 'duration' in settings else GlobalConfig.sim_duration, "slot_length": duration(seconds=settings['slot_length'].seconds) if 'slot_length' in settings else GlobalConfig.slot_length, "tick_length": duration(seconds=settings['tick_length'].seconds) if 'tick_length' in settings else GlobalConfig.tick_length, "market_maker_rate": settings.get( 'market_maker_rate', str(ConstSettings.GeneralSettings.DEFAULT_MARKET_MAKER_RATE)), "market_count": settings.get('market_count', GlobalConfig.market_count), "cloud_coverage": settings.get('cloud_coverage', GlobalConfig.cloud_coverage), "pv_user_profile": settings.get('pv_user_profile', None), "max_panel_power_W": settings.get('max_panel_power_W', ConstSettings.PVSettings.MAX_PANEL_OUTPUT_W), "grid_fee_type": settings.get('grid_fee_type', GlobalConfig.grid_fee_type), "external_connection_enabled": settings.get('external_connection_enabled', False), "aggregator_device_mapping": aggregator_device_mapping } if GlobalConfig.IS_CANARY_NETWORK: config_settings['start_date'] = \ instance((datetime.combine(date.today(), datetime.min.time()))) validate_global_settings(config_settings) slot_length_realtime = duration(seconds=settings['slot_length_realtime'].seconds) \ if 'slot_length_realtime' in settings else None config = SimulationConfig(**config_settings) spot_market_type = settings.get('spot_market_type', None) if spot_market_type is not None: if spot_market_type == SpotMarketTypeEnum.ONE_SIDED.value: ConstSettings.IAASettings.MARKET_TYPE = SpotMarketTypeEnum.ONE_SIDED.value if spot_market_type == SpotMarketTypeEnum.TWO_SIDED_PAY_AS_BID.value: ConstSettings.IAASettings.MARKET_TYPE = ( SpotMarketTypeEnum.TWO_SIDED_PAY_AS_BID.value) ConstSettings.IAASettings.BID_OFFER_MATCH_TYPE = ( BidOfferMatchAlgoEnum.PAY_AS_BID.value) if spot_market_type == SpotMarketTypeEnum.TWO_SIDED_PAY_AS_CLEAR.value: ConstSettings.IAASettings.MARKET_TYPE = ( SpotMarketTypeEnum.TWO_SIDED_PAY_AS_BID.value) ConstSettings.IAASettings.BID_OFFER_MATCH_TYPE = \ BidOfferMatchAlgoEnum.PAY_AS_CLEAR.value if spot_market_type == SpotMarketTypeEnum.TWO_SIDED_EXTERNAL.value: ConstSettings.IAASettings.MARKET_TYPE = ( SpotMarketTypeEnum.TWO_SIDED_PAY_AS_BID.value) ConstSettings.IAASettings.BID_OFFER_MATCH_TYPE = \ BidOfferMatchAlgoEnum.EXTERNAL.value if scenario is None: scenario_name = "default_2a" elif scenario in available_simulation_scenarios: scenario_name = scenario else: scenario_name = 'json_arg' config.area = scenario kwargs = { "no_export": True, "pricing_scheme": 0, "seed": settings.get('random_seed', 0) } run_simulation(setup_module_name=scenario_name, simulation_config=config, simulation_events=events, redis_job_id=job_id, saved_sim_state=saved_state, slot_length_realtime=slot_length_realtime, kwargs=kwargs) except Exception: import traceback from d3a.d3a_core.redis_connections.redis_communication import publish_job_error_output publish_job_error_output(job_id, traceback.format_exc()) logging.getLogger().error( f"Error on jobId {job_id}: {traceback.format_exc()}")
def start(scenario, settings, events, aggregator_device_mapping): logging.getLogger().setLevel(logging.ERROR) scenario = decompress_and_decode_queued_strings(scenario) job = get_current_job() job.save_meta() try: if settings is None: settings = {} else: settings = { k: v for k, v in settings.items() if v is not None and v != "None" } advanced_settings = settings.get('advanced_settings', None) if advanced_settings is not None: update_advanced_settings(ast.literal_eval(advanced_settings)) aggregator_device_mapping = json.loads(aggregator_device_mapping) if events is not None: events = ast.literal_eval(events) config_settings = { "start_date": instance( datetime.combine(settings.get('start_date'), datetime.min.time())) if 'start_date' in settings else GlobalConfig.start_date, "sim_duration": duration(days=settings['duration'].days) if 'duration' in settings else GlobalConfig.sim_duration, "slot_length": duration(seconds=settings['slot_length'].seconds) if 'slot_length' in settings else GlobalConfig.slot_length, "tick_length": duration(seconds=settings['tick_length'].seconds) if 'tick_length' in settings else GlobalConfig.tick_length, "market_maker_rate": settings.get( 'market_maker_rate', str(ConstSettings.GeneralSettings.DEFAULT_MARKET_MAKER_RATE)), "market_count": settings.get('market_count', GlobalConfig.market_count), "cloud_coverage": settings.get('cloud_coverage', GlobalConfig.cloud_coverage), "pv_user_profile": settings.get('pv_user_profile', None), "max_panel_power_W": settings.get('max_panel_power_W', ConstSettings.PVSettings.MAX_PANEL_OUTPUT_W), "grid_fee_type": settings.get('grid_fee_type', GlobalConfig.grid_fee_type), "external_connection_enabled": settings.get('external_connection_enabled', False), "aggregator_device_mapping": aggregator_device_mapping } validate_global_settings(config_settings) config = SimulationConfig(**config_settings) spot_market_type = settings.get('spot_market_type', None) if spot_market_type is not None: ConstSettings.IAASettings.MARKET_TYPE = spot_market_type if scenario is None: scenario_name = "default_2a" elif scenario in available_simulation_scenarios: scenario_name = scenario else: scenario_name = 'json_arg' config.area = scenario kwargs = { "no_export": True, "pricing_scheme": 0, "seed": settings.get('random_seed', 0) } slowdown_factor = environ.get('D3A_SLOWDOWN_FACTOR', None) if slowdown_factor is None: slowdown_factor = settings.get('slowdown', 0) else: slowdown_factor = float(slowdown_factor) run_simulation(setup_module_name=scenario_name, simulation_config=config, simulation_events=events, slowdown=slowdown_factor, redis_job_id=job.id, kwargs=kwargs) except Exception: import traceback from d3a.d3a_core.redis_connections.redis_communication import publish_job_error_output publish_job_error_output(job.id, traceback.format_exc()) logging.getLogger().error( f"Error on jobId {job.id}: {traceback.format_exc()}")