def __init__(self):
self.pymortar_client = pymortar.Client()
price_path = PRICE_DATA_PATH / "price-mapping.csv"
if not os.path.isfile(str(price_path)):
logging.critical("Error: could not find file at: %s",
str(price_path))
sys.exit()
self.price_mapping = pd.read_csv(str(price_path))
tariffs_utilities = []
self.all_tariffs_utilities_dfs = {}
for utility, tariffs in ALL_TARIFFS_UTILITIES.items():
for tariff in tariffs:
tariffs_utilities.append(
price_pb2.TariffUtilityReply(tariff=tariff,
utility=utility))
df = pd.read_csv(
PRICE_DATA_PATH /
("prices_01012017_040172019/" + tariff + ".csv"),
index_col=[0],
parse_dates=False)
df = df.fillna(0)
df.index = pd.to_datetime(df.index)
df = df.tz_localize("US/Pacific",
nonexistent='shift_forward',
ambiguous=False).tz_convert(pytz.utc)
self.all_tariffs_utilities_dfs[tariff] = df
self.all_tariffs_utilities = price_pb2.AllTariffUtilityReply(
tariffs_utilities=tariffs_utilities)
def evaluate(site, date, model_name='best'):
cli = pymortar.Client()
date = pd.to_datetime(date).date()
import sys
best_model_path = './models/{}/{}'.format(site, model_name)
model_file = open(best_model_path, 'rb')
best_model = pickle.load(model_file)
actual, prediction, event_weather, baseline_weather = best_model.predict(
site, date)
weather_mean = event_weather[((event_weather.index.hour >= 14) &
(event_weather.index.hour <= 18))].mean()
daily_data = get_daily_data(site, actual, prediction)
return {
'site': site,
'date': date,
'energy cost': {
'actual': daily_data['actual_cost'],
'baseline': daily_data['baseline_cost']
},
'OAT_mean': {
'event': weather_mean['weather'],
'baseline': baseline_weather
},
'baseline-type': best_model.name,
'baseline-rmse': best_model.rmse,
'actual': actual.values,
'baseline': prediction.values
}
def __init__(self):
""" Constructor.
Note
----
For pymortar, set the evironment variables - $MORTAR_API_USERNAME & $MORTAR_API_PASSWORD.
For Mac,
1. vi ~/.bash_profile
2. Add at the end of file,
1. export $MORTAR_API_USERNAME=username
2. export $MORTAR_API_PASSWORD=password
3. source ~/.bash_profile
"""
# Pymortar client
self.pymortar_client = pymortar.Client()
# List of zones in building
building_names_stub = xbos_services_getter.get_building_zone_names_stub(
)
self.supported_buildings = xbos_services_getter.get_buildings(
building_names_stub)
self.pymortar_objects = {
'MEAN': pymortar.MEAN,
'MAX': pymortar.MAX,
'MIN': pymortar.MIN,
'COUNT': pymortar.COUNT,
'SUM': pymortar.SUM,
'RAW': pymortar.RAW
}
def setup(self, cfg):
self.pymortar_client = pymortar.Client({
'username':
cfg['mortar_api_username'],
'password':
cfg['mortar_api_password']
})
self.bacnet = BAC0.connect()
# A dictionary mapping BACnet point names to their Brick classes grouped by Equipment class
self.point_class_dict = get_point_class_dict(self.pymortar_client,
cfg['building'])
# A list of all the BACnet devices in the network
self.devices = [
BAC0.device(dev[2], dev[3], self.bacnet)
for dev in self.bacnet.devices
]
def zone_comfort_evaluation(sensor, index):
"""
Evaluate long-term thermal comfort for all buildings
Parameters
----------
sensor : str
sensor name type to evaluate e.g. Zone_Air_Temperature
index : str
calculation method name e.g. hourly_outlier
Returns
----------
p : float
percentage of the time
"""
# build query and get which sites have the point to do this analysis
qualify_resp, query = _query_and_qualify(sensor)
# connect client to Mortar frontend server
client = pymortar.Client("https://beta-api.mortardata.org")
# evalute all available sites
for i in qualify_resp.sites:
# get the metadata of all query sensors at a specific site
metadata = client.sparql(query, sites=[i])
# get a datafame from each sensor at the site
for idxi, row in metadata.iterrows():
# get data for sensor through all time
query_resp = client.data_uris([row['sensor']])
df = query_resp.data
# parse the hour and weekday info and add it as a column
df['hr'] = pd.to_datetime(df['time']).dt.hour
df['wk'] = pd.to_datetime(df['time']).dt.dayofweek
# get rows that among the specified office hours during weekdays
df_occ = df[(df['hr'] >= 9) & (df['hr'] < 17) &
(df['wk'] >= 0) & (df['wk'] <= 4)]
print('##### App has finished #####')
def _query_and_qualify(sensor):
"""
Build query to return zone air temperature measurements and qualify
which site can run this application
Parameters
----------
sensor : sensor name type to evaluate e.g. Zone_Air_Temperature
Returns
-------
qualify_resp : Mortar QualifyResponse object
query : dictionary with query and sensor
"""
# connect to client
client = pymortar.Client(MORTAR_URL)
# initialize container for query information
query = dict()
# define queries for input sensors and setpoints
sensor_query = """SELECT ?sensor ?equip WHERE {{
?sensor rdf:type/rdfs:subClassOf* brick:{0}_Sensor .
?sensor brick:isPointOf ?equip .
}}""".format(sensor)
setpoint_query = """SELECT ?sp ?equip WHERE {{
?sp rdf:type/rdfs:subClassOf* brick:{0}_Setpoint .
?sp brick:isPointOf ?equip .
}}""".format(sensor)
# find sites with input sensors and setpoints
qualify_resp = client.qualify({"measurement": sensor_query, "setpoint": setpoint_query})
# if qualify_resp.error != "":
# print("ERROR: ", qualify_resp.error)
# os.exit(1)
# save queries and sensor information
query['query'] = dict()
query['query']['sensor'] = sensor_query
query['query']['setpoint'] = setpoint_query
query['sensor'] = sensor
print("running on {0} sites".format(len(qualify_resp.sites)))
print(qualify_resp.sites)
return qualify_resp, query
def __init__(self):
try:
self.pymortar_client = pymortar.Client()
outdoor_temperature_historical_path = OUTDOOR_TEMPERATURE_HISTORICAL_DATA_PATH / "weather-mapping.csv"
if not os.path.isfile(str(outdoor_temperature_historical_path)):
logging.critical("Error: could not find file at: %s",
str(outdoor_temperature_historical_path))
sys.exit()
self.weather_mapping = pd.read_csv(
str(outdoor_temperature_historical_path))
self.fb_prophet_models = train_models(self.weather_mapping,
self.pymortar_client)
print("ready to serve")
except Exception:
tb = traceback.format_exc()
logging.critical(
"Error: failed to initialize microservice or models: %s", tb)
sys.exit()
def main():
pymortar_client = pymortar.Client()
buildings = ['orinda-public-library']
proto_json = gen_proto_json() if os.path.exists('hvac.proto') and os.stat("hvac.proto").st_size != 0 else {}
f = open("hvac.proto","w+")
clustered_equipment = {"Damper": {}, "Fan": {}, "Thermostat": {}}
f.write("syntax = \"proto3\";\r\n\n")
f.write('package xbospb;\n\nimport "brick.proto";\nimport "nullabletypes.proto";\n\n')
for building in buildings:
# Go through all buildings, get equipment, and their respective points
equipment = get_equipment_list(building, pymortar_client)
#Add proto definitions for each piece of equipment
for eq in equipment:
points = dict.fromkeys(get_points_for_equipment(eq, building, pymortar_client), 0)
# Dictates if the current equipment being processed is part of a bigger cluster or
# is going to be its own message in hvac.proto
clustered = False
for clustered_eq in clustered_equipment:
# Union all the clustered equipment
if clustered_eq.lower() in eq.lower():
points = set(clustered_equipment[clustered_eq].keys()).union(points.keys())
clustered_equipment[clustered_eq] = dict.fromkeys(points, 0)
clustered = True
break
if not clustered:
# Write unclustered equipment to hvac.proto
match_proto_numbering_and_write(f, eq, points, proto_json)
# Write all clustered equipment to hvac.proto
for eq in clustered_equipment:
points = clustered_equipment[eq]
if points:
match_proto_numbering_and_write(f, eq, points, proto_json)
f.close()
def evaluate(site, date, model_name='best'):
cli = pymortar.Client()
date = pd.to_datetime(date).date()
best_model_path = './models/{}/{}.txt'.format(site, model_name)
model_file = open(best_model_path, 'rb')
best_model = pickle.load(model_file)
actual, prediction = best_model.predict(site, date)
daily_data = get_daily_data(site, actual, prediction)
return {
'site': site,
'date': date,
'cost': {
'actual': daily_data['actual_cost'],
'baseline': daily_data['baseline_cost']
},
'degree-days': {
'cooling': None,
'heating': None
},
'baseline-type': best_model.name,
'baseline-rmse': best_model.rmse,
'actual': actual.values,
'baseline': prediction.values
}
def read_config():
""" Reads config.json file that contains parameters for baselines and fetches data from Mortar.
Returns
-------
pd.DataFrame(), pd.DataFrame(), default(list), default(list)
meter data, oat data, map of uuid to meter data, map of uuid to oat data
"""
# Instatiate Client
client = pymortar.Client({})
# Query for meter data
query_meter = "SELECT ?meter WHERE { ?meter rdf:type/rdfs:subClassOf* brick:Green_Button_Meter };"
# Query for outdoor air temperature data
query_oat = """ SELECT ?t WHERE { ?t rdf:type/rdfs:subClassOf* brick:Weather_Temperature_Sensor };"""
# Get list of sites for meter data and OAT data
resp_meter = client.qualify([query_meter])
resp_oat = client.qualify([query_oat])
if resp_meter.error or resp_oat.error:
print("ERORR: ", resp_meter.error if True else resp_oat.error)
os._exit(0)
else:
# Get list of sites that are common for meter data and OAT data
common_sites = list(
set(resp_meter.sites).intersection(set(resp_oat.sites)))
# If config['sites'] = "", then default to all sites
if not config['sites']:
config['sites'] = common_sites
else:
for site in config['sites']:
if site not in common_sites:
print('Incorrect site name.')
os._exit(0)
print("Running on {0} sites".format(len(config['sites'])))
# Define the view of meters (metadata)
meter = pymortar.View(
name="view_meter",
sites=config['sites'],
definition=query_meter,
)
# Define the view of OAT (metadata)
oat = pymortar.View(name="view_oat",
sites=config['sites'],
definition=query_oat)
# Define the meter timeseries stream
data_view_meter = pymortar.DataFrame(
name="data_meter", # dataframe column name
aggregation=pymortar.MEAN,
window="15m",
timeseries=[
pymortar.Timeseries(view="view_meter", dataVars=["?meter"])
])
# Define the OAT timeseries stream
data_view_oat = pymortar.DataFrame(
name="data_oat",
aggregation=pymortar.MEAN,
window="15m",
timeseries=[pymortar.Timeseries(view="view_oat", dataVars=["?t"])])
# Define timeframe
time_params = pymortar.TimeParams(start=config['time']['start'],
end=config['time']['end'])
# Form the full request object
request = pymortar.FetchRequest(
sites=config['sites'],
views=[meter, oat],
dataFrames=[data_view_meter, data_view_oat],
time=time_params)
# Fetch data from request
data = client.fetch(request)
# Renames columns from uuids' to sitenames'
map_uuid_meter, map_uuid_oat = map_uuid_sitename(data)
# Save data to csv file
if config['save_data']:
data['data_meter'].to_csv('meter_data.csv')
data['data_oat'].to_csv('oat_data.csv')
return data['data_meter'], data['data_oat'], map_uuid_meter, map_uuid_oat
import pymortar
import time
import pytz
import datetime
from rfc3339 import rfc3339
import xbos_services_getter as xbos
pymortar_client = pymortar.Client()
def get_outside_temp_data(building):
interval = 3600
outside_temperature_query = """SELECT ?temp WHERE {
?temp rdf:type brick:Weather_Temperature_Sensor .
};"""
weather_stations_view = pymortar.View(
name="weather_stations_view",
sites=[building],
definition=outside_temperature_query,
)
weather_stations_stream = pymortar.DataFrame(
name="weather_stations",
aggregation=pymortar.MEAN,
window=str(int(interval)) + 's',
timeseries=[
pymortar.Timeseries(
view="weather_stations_view",
dataVars=["?temp"],
import pandas as pd
from pandas.tseries.holiday import USFederalHolidayCalendar as calendar
from pandas.tseries.offsets import CustomBusinessDay
import matplotlib.pyplot as plt
import numpy as np
import datetime, pytz
from .get_data import get_weather, get_df
from .utils import get_window_of_day
import pymortar
cli = pymortar.Client()
def _remove_PDP_days(data, PDP_list):
try:
for i in PDP_list:
day=datetime.datetime.strptime(str(i), "%Y-%m-%d").date()
data=data[~(data.index.date == day)]
return data
except:
print('error in _remove_PDP_days')
return data
def _remove_WE_holidays_NaN(data, start, end):
def __init__(self):
self.pymortar_client = pymortar.Client()
def read_config():
""" Reads config.json file to obtain parameters and fetch data from Mortar.
Returns
-------
pd.DataFrame(), pd.DataFrame(), default(list), default(list)
meter data, occupancy data, map of uuid to meter data, map of uuid to occupancy data
"""
# Instatiate Client
client = pymortar.Client({})
# Query for meter data
query_meter = "SELECT ?meter WHERE { ?meter rdf:type/rdfs:subClassOf* brick:Green_Button_Meter };"
# Query for occupancy data
query_occupancy = "SELECT ?point WHERE { ?point rdf:type/rdfs:subClassOf* brick:Occupancy_Sensor };"
# Get list of sites for meter data and occupancy data
resp_meter = client.qualify([query_meter])
resp_occupancy = client.qualify([query_occupancy])
if resp_meter.error or resp_occupancy.error:
print("ERORR: ", resp_meter.error if True else resp_occupancy.error)
os._exit(0)
else:
# Get list of sites that are common for meter data and occupancy data
common_sites = list(
set(resp_meter.sites).intersection(set(resp_occupancy.sites)))
# If config['sites'] = "", then default to all sites
if not config['sites']:
config['sites'] = common_sites
else:
for site in config['sites']:
if site not in common_sites:
print('Incorrect site name.')
os._exit(0)
print("Running on {0} sites".format(len(config['sites'])))
# Define the view of meters (metadata)
meter = pymortar.View(
name="view_meter",
sites=config['sites'],
definition=query_meter,
)
# Define the view of OAT (metadata)
occupancy = pymortar.View(name="view_occupancy",
sites=config['sites'],
definition=query_occupancy)
# Define the meter timeseries stream
data_view_meter = pymortar.DataFrame(
name="data_meter", # dataframe column name
aggregation=pymortar.MEAN,
window="15m",
timeseries=[
pymortar.Timeseries(view="view_meter", dataVars=["?meter"])
])
# Define the occupancy timeseries stream
data_view_occupancy = pymortar.DataFrame(
name="data_occupancy", # dataframe column name
aggregation=pymortar.RAW,
window="",
timeseries=[
pymortar.Timeseries(view="view_occupancy", dataVars=["?point"])
])
# Define timeframe
time_params = pymortar.TimeParams(start=config['time']['start'],
end=config['time']['end'])
# Form the full request object
request = pymortar.FetchRequest(
sites=config['sites'],
views=[meter, occupancy],
dataFrames=[data_view_meter, data_view_occupancy],
time=time_params)
# Fetch data from request
response = client.fetch(request)
# Save data to csv file
if config['save_data']:
response['data_meter'].to_csv('meter_data.csv')
response['data_occupancy'].to_csv('occupancy_data.csv')
# Create results folder if it doesn't exist
if not os.path.exists('./' + config['results_folder']):
os.mkdir('./' + config['results_folder'])
return response
import pymortar
import os
import pandas as pd
# use default values (environment variables):
# MORTAR_API_ADDRESS: mortardata.org:9001
# MORTAR_API_USERNAME: required
# MORTAR_API_PASSWORD: required
client = pymortar.Client({})
meter_query = "SELECT ?meter WHERE { ?meter rdf:type/rdfs:subClassOf* brick:Building_Electric_Meter };"
# run qualify stage to get list of sites with electric meters
resp = client.qualify([meter_query])
if resp.error != "":
print("ERROR: ", resp.error)
os.exit(1)
print("running on {0} sites".format(len(resp.sites)))
# define the view of meters (metadata)
meters = pymortar.View(
sites=resp.sites,
name="meters",
definition=meter_query,
)
# define the meter timeseries streams we want
meter_data = pymortar.DataFrame(
name="meters",
aggregation=pymortar.MEAN,
import json
import glob
import os
from bson import json_util
from collections import defaultdict
from functools import update_wrapper
from datetime import datetime, timedelta
from dashutil import get_start, generate_months, prevmonday, get_today
app = Flask(__name__, static_url_path='/static')
config = toml.load('config.toml')
TZ = pytz.timezone('US/Pacific')
client = pymortar.Client({
'mortar_address': config['Mortar']['url'],
'username': config['Mortar']['username'],
'password': config['Mortar']['password'],
})
sites = [config['Dashboard']['sitename']]
# MongoDB configurations
app.config['MONGO_DBNAME'] = 'modes'
app.config["MONGO_URI"] = "mongodb://localhost:27017/modes"
mongo = PyMongo(app)
# Push default modes to mongodb once script starts
INITIALIZED = False
def crossdomain(origin=None,
methods=None,
def _analyze(query, fetch_resp, th_type='abs', th_diff=0.25, th_time=15):
"""
Parameters
----------
query : dictionary with query and sensor
fetch_resp : Mortar FetchResponse object
th_type : Type of comparison performed when evaluating sensor measurement against the setpoint value.
Available options are (any input value within list is valid):
['under', 'u', '-', 'neg', '<'] = return sensors that are under setpoint by th_diff for th_time
['over', 'o', '+', 'pos', '>'] = return sensors that are over setpoint by th_diff for th_time
['outbound', 'outbounds', 'ob', '><'] = return sensors that are either under minimum setpoint value by th_diff
or over maximum setpoint value by th_diff for th_time
['bounded', 'inbounds','inbound', 'ib', '<>'] = return sensors that are within minimum setpoint value + th_diff
and maximum setpoint value - th_diff
['abs', ''] (default type) = return sensors that are +/- th_diff of setpoint value.
th_diff: threshold allowance for determining if sensor measurement is not adhereing to setpoint
in the same units of selected sensor e.g. if 'over' is selected for th_type and 2 for
th_diff then 'bad sensors' will return whenever sensor measurement is setpoint + 2.
th_time : Amount of time in minutes that a sensor measurment needs to meet the selected criteria in order to qualify as 'bad'.
Must be greater or equal and a multiple of the data aggregation window.
window : aggregation window in minutes that the data from sensors and setpoint are in
Returns
-------
None
The app produces a CSV file called `<sensor>_measure_vs_setpoint_<type of analysis>.csv` when run
where '<sensor>' states the sensor type and '<analysis>' states the type of analysis performed.
"""
# connect to client
client = pymortar.Client(MORTAR_URL)
sensor = query['sensor']
comb_metadata = _clean_metadata(fetch_resp)
start = fetch_resp['time']['start']
end = fetch_resp['time']['end']
window = fetch_resp['time']['window']
records = []
for idxi, row in comb_metadata.iterrows():
# get data for sensor and setpoint
sensor_df = client.data_uris([row['sensor']], start=start, end=end, agg='mean', window="{}m".format(window))
setpoint_df = client.data_uris([row['sp']], start=start, end=end, agg='mean', window="{}m".format(window))
if not any([sensor_df.data.empty, setpoint_df.data.empty]):
df = _clean_df(sensor_df.data, setpoint_df.data)
if False:
zone_name = str(row['sensor']).split('#')[1]
csv_name = f"./zone_dat/{row['site']}-{zone_name}-{idxi}.csv"
with open(csv_name, 'w') as fout:
fout.write(f"sensor: {row['sensor']}\n")
fout.write(f"setpoint {row['sp']}\n\n")
df.drop(columns=['sensor_id', 'setpoint_id']).to_csv(fout, index=False)
fout.close
else:
continue
# # for each equipment, pull the UUID for the sensor and setpoint
# q = """
# SELECT sensor_uuid, sp_uuid, {1}_sps.equip, {1}_sps.site
# FROM {1}_sensors
# LEFT JOIN {1}_sps
# ON {1}_sps.equip = {1}_sensors.equip
# WHERE {1}_sensors.equip = "{0}";
# """.format(equip, sensor)
# res = fetch_resp.query(q)
# if len(res) == 0:
# continue
# sensor_col = res[0][0]
# setpoint_col = res[0][1]
# if sensor_col is None or setpoint_col is None:
# continue
# if sensor_col not in sensor_df:
# print('no sensor', sensor_col)
# continue
# if setpoint_col not in setpoint_df:
# print('no sp', setpoint_col)
# continue
# # create the dataframe for this pair of sensor and setpoint
# df = pd.DataFrame([sensor_df[sensor_col], setpoint_df[setpoint_col]]).T
# df.columns = ["{}_sensors".format(sensor), "{}_sps".format(sensor)]
if th_type in ['under', 'u', '-', 'neg', '<']: # if measurement is under sp by th_diff
bad = (df["sensor_val"]) < (df["setpoint_val"] - th_diff)
str_th_type = 'Undershooting'
elif th_type in ['over', 'o', '+', 'pos', '>']: # if measurement is over sp by th_diff
bad = (df["sensor_val"]) > (df["setpoint_val"] + th_diff)
str_th_type = 'Overshooting'
elif th_type in ['outbound', 'outbounds', 'ob', '><']: # if measurement is either below min sp or above max sp by th_diff
max_sp = df["setpoint_val"].max()
min_sp = df["setpoint_val"].min()
bad_max = (df["sensor_val"]) > (max_sp + th_diff)
bad_min = (df["sensor_val"]) < (min_sp - th_diff)
bad = pd.DataFrame([bad_min, bad_max]).all()
str_th_type = 'Exceedance_of_min-max'
elif th_type in ['bounded', 'inbounds','inbound', 'ib', '<>']: # if measurement is either within min and max sp by th_diff
max_sp = df["setpoint_val"].max()
min_sp = df["setpoint_val"].min()
bad_max = (df["sensor_val"]) < (max_sp - th_diff)
bad_min = (df["sensor_val"]) > (min_sp + th_diff)
bad = pd.DataFrame([bad_min, bad_max]).all()
str_th_type = 'Within_min-max'
else:
bad = abs(df["sensor_val"] - df["setpoint_val"]) > th_diff
str_th_type = 'Not_within_setpoint'
if len(df[bad]) == 0: continue
df['same'] = bad.astype(int).diff(1).cumsum()
# this increments every time we get a new run of sensor being below the setpoint
# use this to group up those ranges
df['same2'] = bad.astype(int).diff().ne(0).cumsum()
lal = df[bad].groupby('same2')['same']
# grouped by ranges that meet the predicate (df.sensor + th_diff < df.setpoint)
for g in lal.groups:
idx = list(lal.groups[g])
if len(idx) < 2: continue
data = df[idx[0]:idx[-1]]
if len(data) >= (60/th_time): # multiply by window frame to get hours
fmt = {
'site': row['site'],
'equipment': row['equip'],
'hours': len(data) / (60/window),
'start': idx[0],
'end': idx[-1],
'sensor_val': (data["setpoint_val"]).mean(),
'setpoint_val': (data["sensor_val"]).mean(),
'diff': (data["setpoint_val"] - data["sensor_val"]).mean(),
}
records.append(fmt)
print("{str_th_type} {sensor} for {hours} hours From {start} to {end}, avg diff {diff:.2f}".format(**fmt,
sensor=sensor,
str_th_type=str_th_type))
r = pd.DataFrame(records)
print('##### Saving Results #####')
r.to_csv('{}_measure_vs_setpoint_{}.csv'.format(sensor, str_th_type), index=False)
def _fetch(qualify_resp, query, eval_start_time, eval_end_time, window=15):
"""
Build the fetch query and define the thermal comfort evaluation time.
Parameters
----------
qualify_resp : Mortar QualifyResponse object
query : dictionary with query and sensor
eval_start_time : start date and time in format (yyyy-mm-ddTHH:MM:SSZ) for the thermal
comfort evaluation period
eval_end_time : end date and time in format (yyyy-mm-ddTHH:MM:SSZ) for the thermal
comfort evaluation period
window : aggregation window in minutes to average the measurement data
Returns
-------
fetch_resp : Mortar FetchResponse object
"""
# connect to client
client = pymortar.Client(MORTAR_URL)
sensor = query['sensor']
sensor_query = query['query']['sensor']
setpoint_query = query['query']['setpoint']
# build the fetch request
avail_sites = qualify_resp.sites
# request = pymortar.FetchRequest(
# sites=req_sites,
# views=[
# pymortar.View(
# name="{}_sensors".format(sensor),
# definition=sensor_query,
# ),
# pymortar.View(
# name="{}_sps".format(sensor),
# definition=setpoint_query,
# )
# ],
# dataFrames=[
# pymortar.DataFrame(
# name="sensors",
# aggregation=pymortar.MEAN,
# window="{}m".format(window),
# timeseries=[
# pymortar.Timeseries(
# view="{}_sensors".format(sensor),
# dataVars=["?sensor"],
# )
# ]
# ),
# pymortar.DataFrame(
# name="setpoints",
# aggregation=pymortar.MEAN,
# window="{}m".format(window),
# timeseries=[
# pymortar.Timeseries(
# view="{}_sps".format(sensor),
# dataVars=["?sp"],
# )
# ]
# )
# ],
# time=pymortar.TimeParams(
# start=eval_start_time,
# end=eval_end_time,
# )
# )
# call the fetch api
# fetch_resp = client.fetch(request)
# print(fetch_resp)
# fetch point metadata
sensor_view = client.sparql(sensor_query, sites=avail_sites).reset_index(drop=True)
setpoint_view = client.sparql(setpoint_query, sites=avail_sites).reset_index(drop=True)
fetch_resp = dict()
fetch_resp['sensor'] = sensor_view
fetch_resp['setpoint'] = setpoint_view
# save time parameters
fetch_resp['time'] = dict()
fetch_resp['time']['start'] = eval_start_time
fetch_resp['time']['end'] = eval_end_time
fetch_resp['time']['window'] = window
return fetch_resp
def __init__(self):
""" Constructor. """
self.client = pymortar.Client({})
import pymortar
from pymortar.mortar_pb2 import FetchRequest
c = pymortar.Client('http://localhost:5001')
resp = c.qualify([
"SELECT ?s ?equip WHERE { ?s a brick:Temperature_Sensor . ?s brick:isPointOf ?equip }",
"SELECT ?vav WHERE { ?vav a brick:VAV . ?vav brick:feeds ?zone . ?zone a brick:HVAC_Zone }",
])
air_temp_sensor_query = """SELECT ?sensor ?equip WHERE {
?sensor a brick:Air_Temperature_Sensor .
?sensor brick:isPointOf ?equip
}"""
air_temp_setpoint_query = """SELECT ?sp ?equip WHERE {
?sp a brick:Air_Temperature_Setpoint .
?sp brick:isPointOf ?equip
}"""
qualify_resp = c.qualify([air_temp_sensor_query, air_temp_setpoint_query])
print(qualify_resp)
print("running on {0} sites".format(len(qualify_resp.sites)))
request = pymortar.FetchRequest(sites=qualify_resp.sites,
views=[
pymortar.View(
name="airtemp_sensors",
definition=air_temp_sensor_query,
),
pymortar.View(
name="airtemp_sps",
definition=air_temp_setpoint_query,
