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()}")
