def calculate_efficiency():
hours = cfg.efficiency.hours
timespan = datetime.now() - timedelta(hours=hours)
with db.session_scope() as session:
amount_minutes = session.query(
db.History.chiller1_status,
db.History.chiller2_status,
db.History.chiller3_status,
db.History.chiller4_status,
).order_by(desc(db.History.id)).filter(
db.History.mode == 1, db.History.timestamp > timespan,
or_(db.History.chiller1_status == 1,
db.History.chiller2_status == 1,
db.History.chiller3_status == 1,
db.History.chiller4_status == 1)).count()
rows = session.query(
db.History.return_temp, db.History.effective_setpoint).order_by(
desc(db.History.id)).filter(
db.History.timestamp > timespan).subquery()
effective_setpoint_avg, inlet_temp_avg = session.query(
func.avg(rows.c.effective_setpoint),
func.avg(rows.c.return_temp)).first()
effective_setpoint_avg = effective_setpoint_avg or 0
inlet_temp_avg = inlet_temp_avg or 0
average_temperature_difference = round(
inlet_temp_avg - effective_setpoint_avg, 1)
chiller_efficiency = round(amount_minutes / float(4 * 60 * hours), 1)
return {
"average_temperature_difference": average_temperature_difference,
"chillers_efficiency": chiller_efficiency
}
def update_history(self):
logger.debug("Updating history")
mode = self.mode
if mode in (WINTER, SUMMER):
with db.session_scope() as session:
parameters = db.History(
outside_temp=self.outside_temp,
effective_setpoint=self.effective_setpoint,
water_out_temp=self.water_out_temp,
return_temp=self.return_temp,
boiler_status=self.boiler.status,
cascade_fire_rate=self.boiler.cascade_current_power,
lead_fire_rate=self.boiler.lead_firing_rate,
chiller1_status=self.chiller1.status,
chiller2_status=self.chiller2.status,
chiller3_status=self.chiller3.status,
chiller4_status=self.chiller4.status,
tha_setpoint=self.tha_setpoint,
setpoint_offset_winter=self.setpoint_offset_winter,
setpoint_offset_summer=self.setpoint_offset_summer,
tolerance=self.tolerance,
boiler_manual_override=self.boiler.manual_override,
chiller1_manual_override=self.chiller1.manual_override,
chiller2_manual_override=self.chiller2.manual_override,
chiller3_manual_override=self.chiller3.manual_override,
chiller4_manual_override=self.chiller4.manual_override,
mode=mode,
cascade_time=self.cascade_time,
wind_speed=self.wind_speed,
avg_outside_temp=self.wind_chill_avg,
avg_cascade_fire_rate=self.cascade_fire_rate_avg,
delta=self.current_delta)
session.add(parameters)
def get_data_from_web(self):
logger.debug("Retrieve data from web.")
try:
content = urllib2.urlopen(WEATHER_URL, timeout=5)
last_line = content.readlines()[-1].split()
wind_speed = float(last_line[7])
outside_temp = float(last_line[2])
except (ValueError, IOError, urllib2.HTTPError, urllib2.URLError):
logger.error(
"Unable to get data from the website. Reading previous value from the DB."
)
with db.session_scope() as session:
wind_speed, outside_temp = session.query(
db.History.wind_speed, db.History.outside_temp).order_by(
desc(db.History.id)).first()
if outside_temp != self._outside_temp:
socketio_client.send({
"event": "misc",
"message": {
"outside_temp": outside_temp
}
})
self._outside_temp = outside_temp
self._wind_speed = wind_speed
return {"outside_temp": outside_temp, "wind_speed": wind_speed}
def _update_value_in_db(self, **kwargs):
device = getattr(db, self.table_class_name)
to_backup = kwargs.pop("to_backup", False)
with db.session_scope() as session:
property_ = session.query(device).filter(
device.backup == to_backup).first()
for key, value in kwargs.items():
setattr(property_, key, value)
def _update_settings(self, name, value):
with db.session_scope() as session:
property_ = session.query(db.Settings).first()
setattr(property_, name, value)
if name == "cascade_time":
value /= 60
if name != "mode_switch_timestamp":
socketio_client.send({"event": "misc", "message": {name: value}})
def get_last_data():
with db.session_scope() as session:
history = session.query(db.History).order_by(desc(
db.History.id)).first()
settings = session.query(db.Settings).first()
session.expunge(history)
session.expunge(settings)
return history, settings
def wind_chill_avg(self):
with db.session_scope() as session:
result = session.query(db.History.outside_temp).filter(
db.History.timestamp > (datetime.now() -
timedelta(days=4))).subquery()
wind_chill_avg, = session.query(func.avg(
result.c.outside_temp)).first()
wind_chill_avg = wind_chill_avg or self.outside_temp
return int(round(wind_chill_avg))
def cascade_fire_rate_avg(self):
timespan = datetime.now() - timedelta(hours=cfg.efficiency.hours)
with db.session_scope() as session:
result = session.query(db.History.cascade_fire_rate).order_by(
desc(db.History.id)).filter(
db.History.mode == WINTER,
db.History.timestamp > timespan).subquery()
average_cascade_fire_rate, = session.query(
func.avg(result.c.cascade_fire_rate)).first()
return average_cascade_fire_rate or 0
def _get_property_from_db(self, *args, **kwargs):
device = getattr(db, self.table_class_name)
from_backup = kwargs.pop("from_backup", False)
with db.session_scope() as session:
instance = session.query(device).filter(
device.backup == from_backup).first()
result = [getattr(instance, arg) for arg in args]
if len(result) == 1:
result = result[0]
return result
def get_chart_data():
with db.session_scope() as session:
rows = session.query(
db.History.return_temp,
db.History.timestamp,
db.History.water_out_temp,
).order_by(desc(db.History.id)).limit(40).all()
data = [{
"column-1": row.water_out_temp,
"column-2": row.return_temp,
"date": row.timestamp.strftime("%Y-%m-%d %H:%M")
} for row in reversed(rows)]
return json.dumps(data)
def log_generator():
slice_ = 256
offset = 0
limit = 256
stop = False
log_limit = datetime.now() - timedelta(days=1)
headers = [
"LID", "logdatetime", "outsideTemp", "effective_setpoint",
"waterOutTemp", "returnTemp", "boilerStatus", "cascadeFireRate",
"leadFireRate", "chiller1Status", "chiller2Status", "chiller3Status",
"chiller4Status", "setPoint2", "parameterX_winter",
"parameterX_summer", "t1", "MO_B", "MO_C1", "MO_C2", "MO_C3", "MO_C4",
"mode", "CCT", "windSpeed", "avgOutsideTemp"
]
yield ",".join(headers) + "\n"
while not stop:
with db.session_scope() as session:
rows = session.query(
db.History.id, db.History.timestamp, db.History.outside_temp,
db.History.effective_setpoint, db.History.water_out_temp,
db.History.return_temp, db.History.boiler_status,
db.History.cascade_fire_rate, db.History.lead_fire_rate,
db.History.chiller1_status, db.History.chiller2_status,
db.History.chiller3_status, db.History.chiller4_status,
db.History.tha_setpoint, db.History.setpoint_offset_winter,
db.History.setpoint_offset_summer, db.History.tolerance,
db.History.boiler_manual_override,
db.History.chiller1_manual_override,
db.History.chiller2_manual_override,
db.History.chiller3_manual_override,
db.History.chiller4_manual_override, db.History.mode,
db.History.cascade_time,
db.History.wind_speed, db.History.avg_outside_temp).order_by(
desc(db.History.id)).slice(offset, limit).all()
offset += slice_
limit += slice_
if rows:
for row in rows:
if row[1] > log_limit:
str_row = [
row.strftime("%d %b %I:%M %p") if isinstance(
row, datetime) else str(row) for row in row
]
yield ",".join(str_row) + "\n"
else:
stop = True
break
else:
stop = True
def get_settings():
with db.session_scope() as session:
result = session.query(db.Settings).first()
settings = {
"Mode change delta temp": result.mode_change_delta_temp,
"Mode switch lockout time": result.mode_switch_lockout_time,
"Setpoint max": result.setpoint_max,
"Setpoint min": result.setpoint_min,
"Cascade time": result.cascade_time,
"Setpoint offset winter": result.setpoint_offset_winter,
"Setpoint offset summer": result.setpoint_offset_summer,
"Tolerance": result.tolerance,
"Mode": result.mode
}
return settings
def baseline_setpoint(self):
wind_chill = int(round(self.outside_temp))
if wind_chill < 11:
baseline_setpoint = 100
else:
with db.session_scope() as session:
baseline_setpoint, = session.query(
db.SetpointLookup.setpoint).filter(
db.SetpointLookup.wind_chill == wind_chill).first()
if baseline_setpoint != self._baseline_setpoint:
socketio_client.send({
"event": "misc",
"message": {
"baseline_setpoint": baseline_setpoint
}
})
self._baseline_setpoint = baseline_setpoint
return baseline_setpoint
def tha_setpoint(self):
if self.wind_chill_avg < 71:
temperature_history_adjsutment = 0
else:
with db.session_scope() as session:
temperature_history_adjsutment, = session.query(
db.SetpointLookup.setpoint_offset).filter(
db.SetpointLookup.avg_wind_chill ==
self.wind_chill_avg).first()
tha_setpoint = self.baseline_setpoint - temperature_history_adjsutment
if tha_setpoint != self._tha_setpoint:
socketio_client.send({
"event": "misc",
"message": {
"tha_setpoint": tha_setpoint
}
})
self._tha_setpoint = tha_setpoint
return tha_setpoint
def previous_return_temp(self):
with db.session_scope() as session:
previous_return_temp = session.query(
db.History.return_temp).order_by(desc(
db.History.id)).first()[0]
return float(previous_return_temp)
def _get_settings_from_db(self, param):
param = getattr(db.Settings, param)
with db.session_scope() as session:
value, = session.query(param).first()
return value
def keep_history_for_last_week():
with db.session_scope() as session:
old_history = session.query(db.History).filter(
db.History.timestamp < (datetime.now() - timedelta(days=7)))
old_history.delete()
def three_minute_avg_delta():
with db.session_scope() as session:
result = session.query(db.History.delta).order_by(desc(
db.History.id)).limit(3).subquery()
avg_result, = session.query(func.avg(result.c.delta)).first()
return avg_result
