def setUp(self):
self.env = BaseEnvironment()
self.heat_storage = Mock(spec=SimulatedHeatStorage)()
self.power_meter = Mock(spec=SimulatedPowerMeter)
self.cu = SimulatedCogenerationUnit(1, self.env)
self.cu.heat_storage = self.heat_storage
self.cu.power_meter = self.power_meter
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 test_dshw_forecast(self):
hourly_data = StatisticalForecast.make_hourly(self.dataset, 6)
env = BaseEnvironment()
fc = DSHWForecast(env, hourly_data, try_cache=False)
self.assertTrue(
len(fc.demands[0]) >= fc.input_hours,
"the day series only contains " + str(len(fc.demands[0]) / 24) +
" days, not " + str(fc.input_weeks * 7))
def setUp(self):
self.env = BaseEnvironment()
self.heat_storage = Mock(spec=SimulatedHeatStorage)
self.power_meter = SimulatedPowerMeter(0, self.env)
self.cu = SimulatedCogenerationUnit(1, self.env)
self.cu.heat_storage = self.heat_storage
self.cu.power_meter = self.power_meter
self.cu.config['minimal_workload'] = 0.20
self.cu.off_time = self.env.now - 1
self.gas_input = 20.0
self.cu.config['max_gas_input'] = self.gas_input
self.electrical_efficiency = 0.25
self.cu.config['electrical_efficiency'] = self.electrical_efficiency
self.thermal_efficiency = 0.7
self.cu.config['thermal_efficiency'] = self.thermal_efficiency
self.total_hours_of_operation = 1
self.cu.total_hours_of_operation = self.total_hours_of_operation
def handle_single_data(self):
sep = os.path.sep
path = os.path.join(
BASE_DIR, "server" + sep + "forecasting" + sep + "devices" + sep +
"data" + sep + "Electricity_1.1-12.6.2014.csv")
raw_dataset = DataLoader.load_from_file(
path, "Strom - Verbrauchertotal (Aktuell)", "\t")
dates = [
int(d) for d in DataLoader.load_from_file(path, "Datum", "\t")
] #StatisticalForecast.make_hourly([int(d) for d in DataLoader.load_from_file(path, "Datum", "\t")],6)
demand = StatisticalForecast.make_hourly(
[float(val) / 1000.0 for val in raw_dataset], 6)
start = calendar.timegm(
datetime(year=2014, month=1, day=2).timetuple())
start_index = approximate_index(dates, start)
train_len = 24 * 7 * 8
trainingdata = demand[start_index:start_index + train_len]
test_start = start_index + train_len
testdata = demand[test_start:test_start + 7 * 24 * 2]
start_forecast = test_start * 3600
end_forecast = start_forecast + len(testdata) * 3600
electrical_forecast = DSHWForecast(BaseEnvironment(
start_forecast, False, False),
trainingdata,
samples_per_hour=1)
forecast = [
electrical_forecast.get_forecast_at(timestamp)
for timestamp in range(start_forecast, end_forecast, 3600)
]
#(forecast, alpha, beta, smoothing) = linear(trainingdata, 24*6,alpha=0.4,beta=0.1)
#forecast_nodaysplit, (alpha, beta, gamma), insample = multiplicative(trainingdata,24*7,len(testdata) ,optimization_type="RMSE")
#forecast_nodaysplit, (alpha, beta, gamma, delta, autocorr), insample = double_seasonal(trainingdata,24,24*7,len(testdata) ,optimization_type="RMSE")
#print alpha, beta, gamma, delta
#print alpha, beta, gamma, rmse_auto, sqrt(sum([(m - n) ** 2 for m, n in zip(forecast_values_auto, testdata)]) / len(testdata))
#print "normal", sqrt(sum([(m - n) ** 2 for m, n in zip(forecast_values_auto, testdata)]) / len(testdata))
#print "split", sqrt(sum([(m - n) ** 2 for m, n in zip(forecast, testdata)]) / len(testdata))
#split_testdata = DayTypeForecast.split_weekdata(testdata,samples_per_hour=1,start_date=datetime.fromtimestamp(start_forecast))
#plot_dataset({"measured": split_testdata[5], "forecasted": electrical_forecast.forecasted_demands[5]}, 0, True)
plot_dataset({"measured": testdata, "forecasted": forecast})
def get_warmwater_consumption_power_with_parameters(
self,
residents=0,
time_in_seconds=10,
temperature=20,
heat_storage_base=15):
''' the result depends on the number of residents,
the current time aka self.env.now
the temperature of warm water and
the base_temperatur of the heat_storage'''
self.consumer.config['residents'] = residents
env = BaseEnvironment(initial_time=time_in_seconds, forecast=True)
self.consumer.env = env
self.consumer.temperature_warmwater = temperature
heat_storage = SimulatedHeatStorage(0, env)
heat_storage.base_temperature = heat_storage_base
self.consumer.heat_storage = heat_storage
return self.consumer.get_warmwater_consumption_power()
def test_split_week_data(self):
hourly_data = StatisticalForecast.make_hourly(self.dataset, 6)
env = BaseEnvironment()
fc = DayTypeForecast(env, hourly_data, try_cache=False)
self.assertTrue(
len(fc.demands) == 7, "week_split does not contain 7 series")
self.assertTrue(
len(fc.demands[0]) / 24 >= fc.input_weeks,
"the day series only contains " + str(len(fc.demands[0]) / 24) +
" days, not " + str(fc.input_weeks) +
" (or at least more than 50)")
# from server.forecasting.tools import plotting
for i in range(7):
# plotting.Plotting.plot_dataset({"measured":fc.demands[i], "forecasted": fc.forecasted_demands[i]}, len(fc.demands[i]), block=True)
rmse = self.rmse(self.dataset_2014[:len(fc.forecasted_demands[i])],
fc.forecasted_demands[i])
self.assertTrue(
rmse < 30.0, "MSE of " + str(rmse) + "for day" + str(i) +
" is way too high")
def setUp(self):
self.env = BaseEnvironment()
self.heat_storage = Mock(spec=SimulatedHeatStorage)()
self.power_meter = SimulatedPowerMeter(0, self.env)
self.cu = SimulatedCogenerationUnit(1, self.env)
self.cu.heat_storage = self.heat_storage
self.cu.power_meter = self.power_meter
self.max_gas_input = 19.0
self.cu.config['max_gas_input'] = self.max_gas_input
self.electrical_efficiency = 0.25
self.cu.config['electrical_efficiency'] = self.electrical_efficiency
self.thermal_efficiency = 0.6
self.cu.config['thermal_efficiency'] = self.thermal_efficiency
self.max_efficiency_loss = 0.10
self.cu.max_efficiency_loss = self.max_efficiency_loss
self.maintenance_interval_hours = 2000
self.cu.config[
'maintenance_interval_hours'] = self.maintenance_interval_hours
self.minimal_workload = 0.40
self.cu.config['minimal_workload'] = self.minimal_workload
self.cu.config['minimal_off_time'] = 5.0 * 60.0
self.off_time = self.env.now
self.cu.off_time = self.off_time
self.current_electrical_production = 0.0
self.cu.current_electrical_production = self.current_electrical_production
self.total_electrical_production = 0.0
self.cu.total_electrical_production = self.total_electrical_production
self.total_thermal_production = 0.0
self.cu.total_thermal_production = self.total_thermal_production
self.total_gas_consumption = 0.0
self.cu.total_gas_consumption = self.total_gas_consumption
self.cu.overwrite_workload = None
self.cu.running = True
self.heat_storage.input_energy = 0
self.power_meter.energy_produced = 0
def test_target_temperature_simulate_consumption(self):
'''the target temperature of the consumer should be set
according to the daily demand'''
daily_demand = [x for x in range(24)]
env = BaseEnvironment(initial_time=1388530800,
forecast=True) # 2014-01-01 00:00:00
heat_storage = SimulatedHeatStorage(0, env)
consumer = SimulatedThermalConsumer(1, env)
consumer.heat_storage = heat_storage
consumer.daily_demand = daily_demand
for index, temperature in enumerate(daily_demand):
consumer.config['target_temperature'] = 0
consumer.simulate_consumption()
self.assertEqual(
consumer.config['target_temperature'], temperature,
"current hour: {0} expected: {1} got: {2}".format(
index, consumer.config['target_temperature'], temperature))
env.now += 60 * 60
'''def test_heat_room(self):
def setUp(self):
env = BaseEnvironment(forecast=True)
self.consumer = SimulatedThermalConsumer(0, env)
self.consumer.heat_storage = SimulatedHeatStorage(1, env)
def setup_forecast(self):
hourly_data = StatisticalForecast.make_hourly(self.dataset, 6)
self.env = BaseEnvironment()
self.forecast = DayTypeForecast(self.env, hourly_data, 1, None,
(0.0000000, 0.0, 1.0))
def setUp(self):
self.env = BaseEnvironment()
self.power_meter = SimulatedPowerMeter(0, env=self.env)
def setUp(self):
self.env = BaseEnvironment()
self.hs = SimulatedHeatStorage(0, env=self.env)