def __init__(self,
initial_time,
configurations=None,
code=None,
forward=None,
forecast=True):
Thread.__init__(self)
self.daemon = True
demomode = Configuration.objects.get(key='system_mode').value == "demo"
self.env = BaseEnvironment(initial_time=initial_time,
forecast=forecast,
step_size=DEFAULT_FORECAST_STEP_SIZE,
demomode=demomode) #get_forecast
if configurations is None:
configurations = DeviceConfiguration.objects.all()
self.devices = get_initialized_scenario(self.env, configurations)
self.measurements = MeasurementStorage(self.env, self.devices)
self.user_function = get_user_function(self.devices, code)
self.progress = 0.0
self.result = None
self.forward = forward
if forward == None:
self.forward = DEFAULT_FORECAST_INTERVAL
self.next_optimization = 0.0
self.use_optimization = get_configuration('auto_optimization')
def __init__(self, initial_time, configurations=None, code=None, forward=None, forecast=True):
Thread.__init__(self)
self.daemon = True
demomode = Configuration.objects.get(key="system_mode").value == "demo"
self.env = BaseEnvironment(
initial_time=initial_time, forecast=forecast, step_size=DEFAULT_FORECAST_STEP_SIZE, demomode=demomode
) # get_forecast
if configurations is None:
configurations = DeviceConfiguration.objects.all()
self.devices = get_initialized_scenario(self.env, configurations)
self.measurements = MeasurementStorage(self.env, self.devices)
self.user_function = get_user_function(self.devices, code)
self.progress = 0.0
self.result = None
self.forward = forward
if forward == None:
self.forward = DEFAULT_FORECAST_INTERVAL
self.next_optimization = 0.0
self.use_optimization = get_configuration("auto_optimization")
class Forecast(Thread):
""" Setup a Forecast Object. A new |env| and new Devices will be created.
Forecasting can either be ran synchronous or asynchronous (threaded)::
foocast = Forecast(time.time(), forward=10*24*3600)
barcast = Forecast(time.time(), forward=2*24*3600)
#run threaded
barcast.start()
#wait until foocast is finished, then get result
resultfoo = foocast.run().get()
# wait until barcast is finished
while resultbar == None:
resultbar = barcast.get()
:param int initial_time: timestamp of the time, at which the forecast starts
:param configurations: cached configurations, if ``None``, retrieve from database
:param code: code to be executed
:param int forward: Time to forecast. Uses `DEFAULT_FORECAST_INTERVAL` if ``None``
:param boolean forecast: Passed to |env| forecast.
"""
def __init__(self, initial_time, configurations=None, code=None, forward=None, forecast=True):
Thread.__init__(self)
self.daemon = True
demomode = Configuration.objects.get(key="system_mode").value == "demo"
self.env = BaseEnvironment(
initial_time=initial_time, forecast=forecast, step_size=DEFAULT_FORECAST_STEP_SIZE, demomode=demomode
) # get_forecast
if configurations is None:
configurations = DeviceConfiguration.objects.all()
self.devices = get_initialized_scenario(self.env, configurations)
self.measurements = MeasurementStorage(self.env, self.devices)
self.user_function = get_user_function(self.devices, code)
self.progress = 0.0
self.result = None
self.forward = forward
if forward == None:
self.forward = DEFAULT_FORECAST_INTERVAL
self.next_optimization = 0.0
self.use_optimization = get_configuration("auto_optimization")
def step(self):
""" execute one step of the simulation.
This steps all devices, auto-optimizes if needed and store the values
"""
execute_user_function(self.env, self.env.forecast, self.devices, self.user_function)
if self.use_optimization and self.next_optimization <= 0.0:
auto_optimize(self)
self.next_optimization = 3600.0
# call step function for all devices
for device in self.devices:
device.step()
self.store_values()
self.env.now += self.env.step_size
self.next_optimization -= self.env.step_size
def run(self):
""" run the main loop. Returns self after finishing.
Results are obtained with :meth:`get`"""
time_remaining = self.forward
while time_remaining > 0:
self.step()
self.progress = (1.0 - time_remaining / float(self.forward)) * 100
time_remaining -= self.env.step_size
self.result = {
"start": datetime.fromtimestamp(self.env.initial_date).isoformat(),
"step": DEFAULT_FORECAST_STEP_SIZE,
"end": datetime.fromtimestamp(self.env.now).isoformat(),
"sensors": self.measurements.get_cached(),
}
return self
def store_values(self):
""" sample device values"""
self.measurements.take_and_cache()
def get(self):
""" return the result of the forecast.
If the mainloop is still forecasting, ``None`` is returned.
outputs a dict with::
result = {start: datetime,
step: stepsize,
end: datetime,
sensors: list with values per sensor (see MeasurementStorage)}
"""
return self.result
class Forecast(Thread):
""" Setup a Forecast Object. A new |env| and new Devices will be created.
Forecasting can either be ran synchronous or asynchronous (threaded)::
foocast = Forecast(time.time(), forward=10*24*3600)
barcast = Forecast(time.time(), forward=2*24*3600)
#run threaded
barcast.start()
#wait until foocast is finished, then get result
resultfoo = foocast.run().get()
# wait until barcast is finished
while resultbar == None:
resultbar = barcast.get()
:param int initial_time: timestamp of the time, at which the forecast starts
:param configurations: cached configurations, if ``None``, retrieve from database
:param code: code to be executed
:param int forward: Time to forecast. Uses `DEFAULT_FORECAST_INTERVAL` if ``None``
:param boolean forecast: Passed to |env| forecast.
"""
def __init__(self,
initial_time,
configurations=None,
code=None,
forward=None,
forecast=True):
Thread.__init__(self)
self.daemon = True
demomode = Configuration.objects.get(key='system_mode').value == "demo"
self.env = BaseEnvironment(initial_time=initial_time,
forecast=forecast,
step_size=DEFAULT_FORECAST_STEP_SIZE,
demomode=demomode) #get_forecast
if configurations is None:
configurations = DeviceConfiguration.objects.all()
self.devices = get_initialized_scenario(self.env, configurations)
self.measurements = MeasurementStorage(self.env, self.devices)
self.user_function = get_user_function(self.devices, code)
self.progress = 0.0
self.result = None
self.forward = forward
if forward == None:
self.forward = DEFAULT_FORECAST_INTERVAL
self.next_optimization = 0.0
self.use_optimization = get_configuration('auto_optimization')
def step(self):
""" execute one step of the simulation.
This steps all devices, auto-optimizes if needed and store the values
"""
execute_user_function(self.env, self.env.forecast, self.devices,
self.user_function)
if self.use_optimization and self.next_optimization <= 0.0:
auto_optimize(self)
self.next_optimization = 3600.0
# call step function for all devices
for device in self.devices:
device.step()
self.store_values()
self.env.now += self.env.step_size
self.next_optimization -= self.env.step_size
def run(self):
""" run the main loop. Returns self after finishing.
Results are obtained with :meth:`get`"""
time_remaining = self.forward
while time_remaining > 0:
self.step()
self.progress = (1.0 - time_remaining / float(self.forward)) * 100
time_remaining -= self.env.step_size
self.result = {
'start': datetime.fromtimestamp(self.env.initial_date).isoformat(),
'step': DEFAULT_FORECAST_STEP_SIZE,
'end': datetime.fromtimestamp(self.env.now).isoformat(),
'sensors': self.measurements.get_cached()
}
return self
def store_values(self):
""" sample device values"""
self.measurements.take_and_cache()
def get(self):
""" return the result of the forecast.
If the mainloop is still forecasting, ``None`` is returned.
outputs a dict with::
result = {start: datetime,
step: stepsize,
end: datetime,
sensors: list with values per sensor (see MeasurementStorage)}
"""
return self.result
