Example #1
0
class SMAPDataRetriever(object):
    def __init__(self):
        self.smapc = SmapClient("http://new.openbms.org/backend")

    def get_data(self, room, building, startDate, endDate):
        print "Pulling in data for room : ", room

        data_temp = self.smapc.query("apply window(mean, field='minute',width=10) to data in ('%s','%s') where Metadata/Name='STA_%s____ART'" % (startDate, endDate, room))
        data_reheat = self.smapc.query("apply window(mean, field='minute',width=10) to data in ('%s','%s') where Metadata/Name='STA_%s____RVP'" % (startDate, endDate, room))
        data_flow = self.smapc.query("apply window(mean, field='minute',width=10) to data in ('%s','%s') where Metadata/Name='STA_%s___SVEL'" % (startDate, endDate, room))
        data_oat = self.smapc.query("apply window(mean, field='minute',width=10) to data in ('%s','%s') where Metadata/Name='STA_%s__OAT'" % (startDate, endDate, building))

        data = {}
        for reading in data_temp[0]["Readings"]:
            data[int(reading[0])] = {}
            data[int(reading[0])]["temp"] = float(reading[1])

        for reading in data_reheat[0]["Readings"]:
            data[int(reading[0])]["reheat"] = float(reading[1])

        for reading in data_flow[0]["Readings"]:
            data[int(reading[0])]["flow"] = float(reading[1])

        for reading in data_oat[0]["Readings"]:
            data[int(reading[0])]["outtemp"] = float(reading[1])
        return data
def query_data_old(VAV_Obj, sensor_name, start_date='4/1/2015',
               end_date='4/2/2015', interpolation_time='5min', limit=-1,
               externalID=None, useOptions=False):
    if useOptions:
        start_date = Options.data['starttime']
        end_date = Options.data['endtime']
        interpolation_time = Options.data['interpolationtime']
        limit = eval(Options.data['limit'])
        
    client_obj = SmapClient(VAV_Obj.serverAddr)
    if (VAV_Obj.sensors is None or VAV_Obj.sensors.get(sensor_name) is None) and externalID is None:
        print 'no ' + sensor_name + ' info'
        return None


    if externalID is None:
        sensorID = VAV_Obj.sensors.get(sensor_name)[0]
    else:
        sensorID = externalID
    if start_date is None and end_date is None:
        #print 'select data before now limit ' + str(limit) + ' where uuid = \'' + self.sensors.get(sensor_name)[0] + '\''
        # x = client_obj.query('select data before now limit ' + str(limit) + ' where uuid = \'' + self.sensors.get(sensor_name)[0] + '\'')
        q = client_obj.query('select data before now limit ' + str(limit) + ' where uuid = \'' + sensorID + '\'')
    else:
        #print 'select data in (\'' + start_date + '\', \'' + end_date + '\') limit ' + str(limit) + ' where uuid = \'' + self.sensors.get(sensor_name)[0] + '\''
        q = client_obj.query('select data in (\'' + start_date + '\', \'' + end_date + '\') limit ' + str(limit) + ' where uuid = \'' + sensorID + '\'')

    data_table = pd.DataFrame(q[0]['Readings'], columns=['Time', sensor_name])
    data_table['Time'] = pd.to_datetime(data_table['Time'].tolist(), unit='ms').tz_localize('UTC').tz_convert('America/Los_Angeles')
    data_table.set_index('Time', inplace=True)
    data_table = data_table.groupby(pd.TimeGrouper(interpolation_time)).mean().interpolate(method='linear').dropna()
    return data_table
def queryData(address, where=None, fullQ=None):
    c = SmapClient(address)
    if fullQ is None:
        qList = c.query("select uuid, Path where " + where)
    else:
        qList = c.query(fullQ)
    return qList
Example #4
0
    def setup(self, opts):
        """Set up what streams are to be subsampled.

        We'll only find new streams on a restart ATM.
        """
        restrict = opts.get(
            "Restrict", "has Path and (not has Metadata/Extra/SourceStream)")
        OperatorDriver.setup(self,
                             opts,
                             shelveoperators=False,
                             raw=True,
                             inherit_metadata=False)
        client = SmapClient(smapconf.BACKEND)
        source_ids = client.tags(restrict, 'uuid, Properties/UnitofMeasure')
        for new in source_ids:
            id = str(new['uuid'])
            if not 'Properties/UnitofMeasure' in new:
                new['Properties/UnitofMeasure'] = ''
            if not id in self.operators:
                o1 = SubsampleOperator([new], 300)
                self.add_operator('/%s/%s' % (id, o1.name), o1)
                o2 = SubsampleOperator([new], 3600)
                self.add_operator('/%s/%s' % (id, o2.name), o2)
        log.msg("Done setting up subsample driver; " + str(len(source_ids)) +
                " ops")
Example #5
0
def openBMS(nodeDic):
  resList = []

  c = SmapClient('http://ar1.openbms.org:8079')

  #counts = c.query(("apply count to data in (%s) streamlimit 50 "
  counts = c.query(("apply count to data in (%s) limit -1 "
		    "where Metadata/Instrument/PartNumber = '%s'") %
		   (nodeDic['periodStr'], nodeDic['id']))
  for v in counts:
	#print "readings : %s" % v['Readings']
	r = np.array(v['Readings'])
	Bcnt = int(v['Metadata']['Instrument']['PartNumber'])
	if len(r):
	    if( 0 < (Bcnt-1600) and (Bcnt-1600) < 151 ):
		Pcnt = np.sum(r[:, 1]) * 100 / (int(nodeDic['period']) * 60 / 5)
		print "THL : %s (%s %s)" % \
		   (v['Metadata']['Instrument']['PartNumber'], Pcnt, "%")
		print "\t(cnt : %s) - %s" % (np.sum(r[:, 1]), v['Properties']['UnitofMeasure'])
	    elif( 0 < (Bcnt-2000) and (Bcnt-2000) < 151 ):
		Pcnt = np.sum(r[:, 1]) * 100 / (int(nodeDic['period']) * 60 / 5)
		print "CO2 : %s (%s %s)" % \
		   (v['Metadata']['Instrument']['PartNumber'], Pcnt, "%")
		print "\t(cnt : %s) - %s" % (np.sum(r[:, 1]), v['Properties']['UnitofMeasure'])
	    elif( 0 < (Bcnt-5000) and (Bcnt-5000) < 151 ):
		Pcnt = np.sum(r[:, 1]) * 100 / (int(nodeDic['period']) * 60 / 10)
		print "PIR : %s (%s %s)" % \
		   (v['Metadata']['Instrument']['PartNumber'], Pcnt, "%")
		print "\t(cnt : %s) - %s" % (np.sum(r[:, 1]), v['Properties']['UnitofMeasure'])
	    resList.append(Pcnt)
	    #print r[:, 0]	#date
	    #print r[:, 1]	#data
	    #prrs.append(np.sum(r[:, 1]) / (3600 * (HOURS) / rate))
  return average(resList)
Example #6
0
    def setup(self, opts):
        self.restrict = opts.get("Restrict")
        self.group = opts.get("Group")
        self.opstr = opts.get("Operator")
        OperatorDriver.setup(self, opts, self.restrict, shelveoperators=False)

        # look up the streams, units, and group tags.
        client = SmapClient()
        streams = client.tags(self.restrict, '*')
                              # 'uuid, Properties/UnitofMeasure, Metadata/SourceName, %s' % 
                              # self.group)
        #print streams
        groupitems = {}

        # find the groups
        for s in streams:
            if not s[self.group] in groupitems:
                groupitems[s[self.group]] = []
            groupitems[s[self.group]].append(s)

        # instantiate one operator per group with the appropriate inputs
        for group, tags in groupitems.iteritems():
            inputs = map(operator.itemgetter('uuid'), tags)
            op = self.operator_class(tags)
            path = '/' + util.str_path(group)
            self.add_operator(path, op)
Example #7
0
 def current(self):
     c = SmapClient()
     latest = c.latest(self.select, streamlimit=1000)
     test = self.get_test()
     levels = []
     for v in latest:
         if len(v['Readings']):
             level = test(v['Readings'][0][1])[0]
             v['level'] = {
                 "priority": level.priority,
                 "description": level.description,
             }
             levels.append(level)
     return latest, max(levels)
 def current(self):
     c = SmapClient()
     latest = c.latest(self.select, streamlimit=1000)
     test = self.get_test()
     levels = []
     for v in latest:
         if len(v['Readings']):
             level = test(v['Readings'][0][1])[0]
             v['level'] = {
                 "priority": level.priority,
                 "description": level.description,
                 }
             levels.append(level)
     return latest, max(levels)
Example #9
0
    def setup(self,opts):
        ""

        restrict=opts.get('Restrict','')
        # client=SmapClient()
        client=SmapClient(HOST)
        source_ids=client.tags(restrict,'uuid, Properties/UnitofMeasure')
        for id in source_ids:
            ""
            uuid=str(id['uuid'])
            if not 'Properties/UnitofMeasure' in id:
                id['Properties/UnitofMeasure'] = ''
            if not uuid in self.operators:
                ""

        RepublishClient()
Example #10
0
 def setup(self, opts):
     url = opts.get('url', 'http://new.openbms.org/backend')
     self.client = SmapClient(url)
     self.limit = float(opts.get('limit', 300))  # Seconds
     self.rate = float(opts.get('rate', 300))
     self.alert_interval = float(opts.get(
         'alert_interval', 86400))  # Minimum seconds between alerts
     smtp_server = opts.get('smtp_server')
     self.server = smtplib.SMTP(smtp_server, 587)
     self.server.starttls()
     self.email = opts.get('email_address')
     pw = opts.get('password')
     self.server.login(self.email, pw)
     self.restrict = opts.get('restrict')
     self.recipient = opts.get('recipient')
     self.carrier = opts.get('carrier')
Example #11
0
    def setup(self, opts, restrict=None, shelveoperators=False, cache=True, raw=False):
        self.load_chunk_size = datetime.timedelta(hours=int(opts.get('ChunkSize', 24)))
        self.source_url = opts.get('SourceUrl', 'http://new.openbms.org/backend')
#        self.source_url = opts.get('SourceUrl', 'http://ar1.openbms.org:8079')
        if not raw and restrict:
            self.restrict = '(' + restrict + ') and not has Metadata/Extra/Operator'
        else:
            self.restrict = restrict

        if shelveoperators:
            self.operators = shelve.open(opts.get('OperatorCache', '.operators'),
                                         protocol=2, writeback=True)
            # sync the operator state periodically and at exit
            util.periodicCallInThread(self.operators.sync).start(60)
            reactor.addSystemEventTrigger('after', 'shutdown', 
                                          self.operators.close)
        else:
            self.operators = {}
            self.oplist = []
        self.arclient = SmapClient(self.source_url)
        self.cache = cache

        # create timeseries from cached operator state
        for sid, oplist in self.operators.iteritems():
            for path, op in oplist.itervalues():
                self.add_operator(path, op)
    def setup(self, opts):
        self.rate = float(opts.get('rate',10))
        # Current state of the points
        self.heatSP=int(opts.get('defaultHeatSetpoint',68))
        self.coolSP=int(opts.get('defaultCoolSetpoint',76))

        self.therm_temp = 70

        self.trim = int(opts.get('trim',0)) # dummy zoneCtrl action

        # create timeseries for zone controller actions
        heatSetPoint = self.add_timeseries('/heatSetpoint', 'F', data_type='double')
        coolSetPoint = self.add_timeseries('/coolSetpoint', 'F', data_type='double')
        # add actuators to them
        heatSetPoint.add_actuator(setpointActuator(controller=self, range=(40,90)))
        coolSetPoint.add_actuator(setpointActuator(controller=self, range=(40,90)))

        # get master set point stream paths
        self.archiver_url = opts.get('archiver_url','http://localhost:8079')
        self.heatSPwhere = opts.get('heatSPwhere', '')
        self.coolSPwhere = opts.get('coolSPwhere', '')
        self.thermwhere = opts.get('thermwhere', '')
        self.tempwhere = opts.get('tempwhere', '')

        print "ZoneController: heat sp where = ", self.heatSPwhere
        print "ZoneController: cool sp where = ", self.coolSPwhere
        print "ZoneController: thermostat where = ", self.thermwhere
        print "ZoneController: temp sensor where = ", self.tempwhere

        self.client = SmapClient(self.archiver_url)

        self.heatSPclient = RepublishClient(self.archiver_url, self.heatSPcb, restrict=self.heatSPwhere)
        self.coolSPclient = RepublishClient(self.archiver_url, self.coolSPcb, restrict=self.coolSPwhere)
        #self.tempclient = RepublishClient(self.archiver_url, self.tempcb, restrict=self.tempwhere)
        self.thermclient = RepublishClient(self.archiver_url, self.thermcb, restrict=self.thermwhere)
Example #13
0
class DataClient(object):
    def __init__(self,login=None):
        """"""

        if login == None:
            login={}
            config=Config(Env.getpath('HOME')+'/common/weatherplotter.conf')
            login['host']=config['smap_server_host']
            login['port']=config["smap_server_port"]
            print login
            self.login=login
        else:
            self.login=login

        print "http://%(host)s:%(port)s" % self.login
        self.c = SmapClient("http://%(host)s:%(port)s" % self.login)




    def get_data(self,uuid,start,end,limit=-1):
        # print start
        # print end
        startTime = dtutil.dt2ts(dtutil.strptime_tz(start, "%m/%d/%Y %H:%M:%S %p" ))
        endTime   = dtutil.dt2ts(dtutil.strptime_tz(end, "%m/%d/%Y %H:%M:%S %p"))
        return self.c.data_uuid(uuid, startTime, endTime,True,limit)
Example #14
0
    def send_alert(self, to, alert, streams, level):
        # look up the tags for these streams
        uuids = set(streams.keys())
        uuids = map(lambda u: "uuid = '%s'" % u, uuids)
        client = SmapClient()
        tags = client.tags(' or '.join(uuids), nest=True)
        tags = dict(((x['uuid'], x) for x in tags))

        def make_context(params):
            rv = []
            for uid, state in params.iteritems():
                t, v = state['time'], state['value']
                if uid in tags:
                    rv.append(tags[uid])
                    rv[-1]['AlertTime'] = time.ctime(t / 1000)
                    rv[-1]['AlertValue'] = v
            return rv

        context = make_context(streams)
        logentry = Log(alert=alert, when=datetime.datetime.now())
        logentry.save()

        # generate the text to send, by building a context for our
        # template.
        template = Template(self.template)
        context = Context({
            'streams':
            context,
            'level':
            level,
            'permalink':
            settings.ROOT_NETLOC + '/admin/alert/log/' + str(logentry.id),
            'alarmpage':
            settings.ROOT_NETLOC + '/admin/alert/alert/' + str(alert.id),
            'timestamp':
            logentry.when,
            'alarm':
            alert.__unicode__(),
        })
        logentry.message = template.render(context)
        print logentry.message
        logentry.save()

        emaillib.send(to, '%s from %s' % (level, settings.ROOT_NETLOC),
                      logentry.message)
Example #15
0
 def __init__(self):
     # vav,chw,vfd naming
     self.vavs_rhv = [
         'S1-01', 'S1-02', 'S1-03', 'S1-04', 'S1-07', 'S1-08', 'S1-09', 'S1-10', 'S1-13', 'S1-15', 'S1-16', 'S1-17', 'S1-18', 'S1-19', 'S1-20',
         'S2-01', 'S2-02', 'S2-03', 'S2-04', 'S2-05', 'S2-06', 'S2-07', 'S2-10', 'S2-11', 'S2-12', 'S2-13', 'S2-14', 'S2-15', 'S2-16', 'S2-17', 'S2-18', 'S2-19', 'S2-20', 'S2-21',
         'S3-01', 'S3-02', 'S3-03', 'S3-04', 'S3-05', 'S3-06', 'S3-07', 'S3-08', 'S3-09', 'S3-10', 'S3-11', 'S3-12', 'S3-15', 'S3-16', 'S3-17', 'S3-18', 'S3-19', 'S3-20', 'S3-21',
         'S4-01', 'S4-02', 'S4-03', 'S4-04', 'S4-05', 'S4-06', 'S4-07', 'S4-08', 'S4-09', 'S4-11', 'S4-12', 'S4-13', 'S4-15', 'S4-16', 'S4-18', 'S4-19', 'S4-20', 'S4-21',
         'S5-01', 'S5-02', 'S5-03', 'S5-04', 'S5-05', 'S5-06', 'S5-07', 'S5-08', 'S5-09', 'S5-10', 'S5-11', 'S5-12', 'S5-13', 'S5-14', 'S5-16', 'S5-18', 'S5-19', 'S5-20', 'S5-21',
         'S6-01', 'S6-02', 'S6-03', 'S6-04', 'S6-05', 'S6-06', 'S6-07', 'S6-08', 'S6-10', 'S6-11', 'S6-12', 'S6-13', 'S6-15', 'S6-17', 'S6-18', 'S6-19', 'S6-20',
         'S7-01', 'S7-02', 'S7-03', 'S7-04', 'S7-05', 'S7-06', 'S7-07', 'S7-08', 'S7-09', 'S7-10', 'S7-13', 'S7-14', 'S7-15', 'S7-16'
     ]
     self.vavs_no_rhv = [
         'S1-05', 'S1-06', 'S1-14', 'S2-08', 'S2-09', 'S3-13', 'S3-14', 'S4-10', 'S4-14', 'S4-17',
         'S5-15', 'S5-17', 'S6-09', 'S6-14', 'S6-16', 'S7-11', 'S7-12'
     ]
     self.vavs = self.vavs_rhv + self.vavs_no_rhv
     self.chw_coils = ['AH2A', 'AH2B']
     self.vfds = ['AH2A', 'AH2B']
     # define component fields
     self.components_by_type = {
         'vfds': self.vfds,
         'chw_coils': self.chw_coils,
         'vavs_rhv': self.vavs_rhv,
         'vavs_no_rhv': self.vavs_no_rhv
     }
     self.datapoints_by_type = {
         'vfds': ['SF_VFD:POWER'],
         'chw_coils': ['SAT', 'MAT', 'CCV', 'SF_CFM'],
         'vavs_no_rhv': ['AIR_VOLUME', 'CTL_FLOW_MIN', 'CTL_FLOW_MAX', 'CTL_STPT'],
         'vavs_rhv': ['AIR_VOLUME', 'CTL_FLOW_MIN', 'CTL_FLOW_MAX', 'CTL_STPT', 'VLV_POS',
                      'CLG_LOOPOUT', 'HTG_LOOPOUT', 'AI_3', 'rhv_closed_temp_change']
     }
     self.unit_of_estimated_data = {
         'rhw_cost': '$/hr', 'fan_cost': '$/hr', 'chw_cost': '$/hr', 'tot_cost': '$/hr',
         'chw_power': 'kW', 'chw_power_AH2A': 'kW', 'chw_power_AH2B': 'kW', 'rhw_power': 'kW',
         'fan_power': 'kW', 'fan_power_from_regression_curve': 'kW',
         'fan_power_AH2A': 'kW', 'fan_power_AH2B': 'kW', 'ahu_afr': 'cfm'
     }
     # define data restriction
     self.restrict_central = "Metadata/SourceName = 'Sutardja Dai Hall BACnet' and Path ~ 'AH2' and " \
         + "(Path ~ 'SAT' or Path ~ 'MAT' or Path ~ 'SF_CFM' or Path ~ 'CCV' or Path ~ 'SF_VFD:POWER') and " \
         + "not (Path ~ 'STP' or Path ~ 'RAH')"
     self.restrict_local = "Metadata/SourceName = 'Sutardja Dai Hall BACnet' and Path ~ 'S[0-9]-[0-9][0-9]' and " \
        + "not (Path ~ 'act') and (Path ~ 'AI_3' or Path ~ 'VLV_POS' or Path ~ 'HTG_LOOPOUT' or " \
        + "Path ~ 'CLG_LOOPOUT' or Path ~ 'AIR_VOLUME' or Path ~ 'ROOM_TEMP' or " \
        + "Path ~ 'CTL_FLOW_MIN' or Path ~ 'CTL_FLOW_MAX' or Path ~ 'CTL_STPT')"
     self.restrict_result = "Metadata/SourceName = 'Sutardja Dai Hall SAT Reset' and Path ~ 'SAT_Reset_debug_20160719' and " \
        + "Path ~ 'rhv_closed_temp_change' or Path ~ 'computed_sat' and " \
        + "not Path ~ 'SAT_Reset_debug_20160719_C'"
     self.restrict_new = "(%s) or (%s) or (%s)" % \
                         (self.restrict_central, self.restrict_local, self.restrict_result)
     self.restrict_oat = "Metadata/SourceName = 'Sutardja Dai Hall BACnet' and Path = '/Siemens/SDH.PXCM-08/SDH/OAT'"
     # creat smap client object
     self.archiver_url = 'http://new.openbms.org/backend'
     self.smap_client = SmapClient(self.archiver_url)
     # parameters
     self.limit = 40
Example #16
0
class DataClient(object):
    def __init__(self,login):
        """"""
        self.c = SmapClient("http://%(host)s:%(port)s" % login)


    def get_data(self,uuid,start,end,limit=-1):
        # print start
        # print end
        startTime = dtutil.dt2ts(dtutil.strptime_tz(start, "%m/%d/%Y %H:%M:%S %p" ))
        endTime   = dtutil.dt2ts(dtutil.strptime_tz(end, "%m/%d/%Y %H:%M:%S %p"))
        return self.c.data_uuid(uuid, startTime, endTime,True,limit)
Example #17
0
    def setup(self, opts):
        """Set up what streams are to be subsampled.

        We'll only find new streams on a restart ATM.
        """
        restrict = opts.get("Restrict", 
                            "has Path and (not has Metadata/Extra/SourceStream)")
        OperatorDriver.setup(self, opts, shelveoperators=False, raw=True,
                             inherit_metadata=False)
        client = SmapClient(smapconf.BACKEND)
        source_ids = client.tags(restrict, 'uuid, Properties/UnitofMeasure')
        for new in source_ids:
            id = str(new['uuid'])
            if not 'Properties/UnitofMeasure' in new:
                new['Properties/UnitofMeasure'] = ''
            if not id in self.operators:
                o1 = SubsampleOperator([new], 300)
                self.add_operator('/%s/%s' % (id, o1.name), o1)
                o2 = SubsampleOperator([new], 3600)
                self.add_operator('/%s/%s' % (id, o2.name), o2)
        log.msg("Done setting up subsample driver; " + str(len(source_ids)) + " ops")
    def send_alert(self, to, alert, streams, level):
        # look up the tags for these streams
        uuids = set(streams.keys())
        uuids = map(lambda u: "uuid = '%s'" % u, uuids)
        client = SmapClient()
        tags = client.tags(' or '.join(uuids), nest=True)
        tags = dict(((x['uuid'], x) for x in tags))

        def make_context(params):
            rv = []
            for uid, state in params.iteritems():
                t, v = state['time'], state['value']
                if uid in tags:
                    rv.append(tags[uid])
                    rv[-1]['AlertTime'] = time.ctime(t/1000)
                    rv[-1]['AlertValue'] = v
            return rv
        context = make_context(streams)
        logentry = Log(alert=alert, 
                       when=datetime.datetime.now())
        logentry.save()

        # generate the text to send, by building a context for our
        # template.
        template = Template(self.template)
        context = Context({
                'streams' :  context,
                'level' : level,
                'permalink' : settings.ROOT_NETLOC + '/admin/alert/log/' + str(logentry.id),
                'alarmpage' : settings.ROOT_NETLOC + '/admin/alert/alert/' + str(alert.id),
                'timestamp' : logentry.when,
                'alarm' : alert.__unicode__(),
                })
        logentry.message = template.render(context)
        print logentry.message
        logentry.save()

        emaillib.send(to, '%s from %s' % (level, settings.ROOT_NETLOC), logentry.message)
Example #19
0
	def read_stream_data(self, num_days=1):
		self.points = {}
		c = SmapClient("http://new.openbms.org/backend")
		for point in self.input_variables:
			q = "apply window(mean, field='second',width='%d') to data in (\"03/01/2015\" -%ddays, \"03/07/2015\") where Metadata/Name='%s'" % \
						( self.rate,  num_days,  point )

			print q
			result = c.query(q)
			readings = result[0]["Readings"]
			self.points[point] = [ r[1] for r in result[0]["Readings"] ]

		for point in self.state_variables:
			query = "apply window(mean, field='second',width='%d') to data in (\"03/01/2015\" -%ddays, \"03/07/2015\") where Metadata/Name='%s'" % \
						( self.rate,  num_days,  point )

			result = c.query(query)
			readings = result[0]["Readings"]
			self.points[point] = [ r[1] for r in result[0]["Readings"] ]

		self.predictions = []
		self.model_params = []
		self.actual_outputs = []
Example #20
0
    def read_stream_data(self, num_days=1):
        self.points = {}
        c = SmapClient("http://new.openbms.org/backend")
        for point in self.input_variables:
            q = "apply window(mean, field='second',width='%d') to data in (\"03/01/2015\" -%ddays, \"03/07/2015\") where Metadata/Name='%s'" % \
               ( self.rate,  num_days,  point )

            print q
            result = c.query(q)
            readings = result[0]["Readings"]
            self.points[point] = [r[1] for r in result[0]["Readings"]]

        for point in self.state_variables:
            query = "apply window(mean, field='second',width='%d') to data in (\"03/01/2015\" -%ddays, \"03/07/2015\") where Metadata/Name='%s'" % \
               ( self.rate,  num_days,  point )

            result = c.query(query)
            readings = result[0]["Readings"]
            self.points[point] = [r[1] for r in result[0]["Readings"]]

        self.predictions = []
        self.model_params = []
        self.actual_outputs = []
Example #21
0
 def setup(self, opts):
   url = opts.get('url', 'http://new.openbms.org/backend') 
   self.client = SmapClient(url)
   self.limit = float(opts.get('limit', 300)) # Seconds
   self.rate = float(opts.get('rate', 300))
   self.alert_interval = float(opts.get('alert_interval', 86400)) # Minimum seconds between alerts
   smtp_server = opts.get('smtp_server')
   self.server = smtplib.SMTP(smtp_server, 587)
   self.server.starttls()
   self.email = opts.get('email_address')
   pw = opts.get('password')
   self.server.login(self.email, pw)
   self.restrict = opts.get('restrict')
   self.recipient = opts.get('recipient')
   self.carrier = opts.get('carrier')
Example #22
0
    def __init__(self,login=None):
        """"""

        if login == None:
            login={}
            config=Config(Env.getpath('HOME')+'/common/weatherplotter.conf')
            login['host']=config['smap_server_host']
            login['port']=config["smap_server_port"]
            print login
            self.login=login
        else:
            self.login=login

        print "http://%(host)s:%(port)s" % self.login
        self.c = SmapClient("http://%(host)s:%(port)s" % self.login)
Example #23
0
class Alert(SmapDriver):
    def setup(self, opts):
        url = opts.get('url', 'http://new.openbms.org/backend')
        self.client = SmapClient(url)
        self.limit = float(opts.get('limit', 300))  # Seconds
        self.rate = float(opts.get('rate', 300))
        self.alert_interval = float(opts.get(
            'alert_interval', 86400))  # Minimum seconds between alerts
        smtp_server = opts.get('smtp_server')
        self.server = smtplib.SMTP(smtp_server, 587)
        self.server.starttls()
        self.email = opts.get('email_address')
        pw = opts.get('password')
        self.server.login(self.email, pw)
        self.restrict = opts.get('restrict')
        self.recipient = opts.get('recipient')
        self.carrier = opts.get('carrier')

    def start(self):
        self.process = periodicSequentialCall(self.read)
        self.process.start(self.rate)

    def read(self):
        data = self.client.latest(self.restrict, streamlimit=-1)
        for d in data:
            uuid = d["uuid"]
            latest = d["Readings"][0][0] / 1000
            now = time.time()
            gap = now - latest
            if gap > self.limit:
                self.alert(uuid)
                self.process.stop()
                reactor.callLater(self.alert_interval, self.start)
                break

    def alert(self, uuid):
        message = '\nGap of more than %s seconds in data for %s: uuid=%s' % (
            self.limit, self.restrict, uuid)
        print message
        self.server.sendmail(self.email,
                             "%s@%s" % (self.recipient, self.carrier), message)
        self.process.stop()
Example #24
0
class Alert(SmapDriver):

  def setup(self, opts):
    url = opts.get('url', 'http://new.openbms.org/backend') 
    self.client = SmapClient(url)
    self.limit = float(opts.get('limit', 300)) # Seconds
    self.rate = float(opts.get('rate', 300))
    self.alert_interval = float(opts.get('alert_interval', 86400)) # Minimum seconds between alerts
    smtp_server = opts.get('smtp_server')
    self.server = smtplib.SMTP(smtp_server, 587)
    self.server.starttls()
    self.email = opts.get('email_address')
    pw = opts.get('password')
    self.server.login(self.email, pw)
    self.restrict = opts.get('restrict')
    self.recipient = opts.get('recipient')
    self.carrier = opts.get('carrier')

  def start(self):
    self.process = periodicSequentialCall(self.read)
    self.process.start(self.rate)

  def read(self):
    data = self.client.latest(self.restrict, streamlimit=-1)
    for d in data:
      uuid = d["uuid"]
      latest = d["Readings"][0][0] / 1000
      now = time.time()
      gap = now - latest
      if gap > self.limit:
        self.alert(uuid)
        self.process.stop()
        reactor.callLater(self.alert_interval, self.start)
        break 

  def alert(self, uuid):
    message = '\nGap of more than %s seconds in data for %s: uuid=%s' % (self.limit, self.restrict, uuid)
    print message
    self.server.sendmail(self.email, "%s@%s" % (self.recipient, self.carrier), message)
    self.process.stop()
Example #25
0
from smap.archiver.client import SmapClient
import time
import datetime
import json
import pandas as pd
#pd.options.display.mpl_style = 'default'

client = SmapClient('http://ciee.cal-sdb.org:8079')
# timestamps
end = int(time.time())
start = end - 60*60*24*30 # last month
print start, end

def get_demand():
    # get energy data for same timeframe
    res = client.query('select uuid where Metadata/System = "Monitoring" and Properties/UnitofMeasure = "kW"')
    uuids = [x['uuid'] for x in res]
    data = dict(zip(uuids,client.data_uuid(uuids, start, end, cache=False)))

    # create dataframe, use time as index
    demand = pd.DataFrame(data.values()[0])
    demand[0] = pd.to_datetime(demand[0], unit='ms')
    demand.index = demand[0]
    del demand[0]
    return demand

def get_hvacstates():
    # get all hvac_state timeseries
    res = client.query('select uuid where Metadata/System = "HVAC" and Path like "%hvac_state"')
    uuids = [x['uuid'] for x in res]
    data = dict(zip(uuids,client.data_uuid(uuids, start, end, cache=False)))
class ZoneController(driver.SmapDriver):
    def setup(self, opts):
        self.rate = float(opts.get('rate',10))
        # Current state of the points
        self.heatSP=int(opts.get('defaultHeatSetpoint',68))
        self.coolSP=int(opts.get('defaultCoolSetpoint',76))

        self.therm_temp = 70

        self.trim = int(opts.get('trim',0)) # dummy zoneCtrl action

        # create timeseries for zone controller actions
        heatSetPoint = self.add_timeseries('/heatSetpoint', 'F', data_type='double')
        coolSetPoint = self.add_timeseries('/coolSetpoint', 'F', data_type='double')
        # add actuators to them
        heatSetPoint.add_actuator(setpointActuator(controller=self, range=(40,90)))
        coolSetPoint.add_actuator(setpointActuator(controller=self, range=(40,90)))

        # get master set point stream paths
        self.archiver_url = opts.get('archiver_url','http://localhost:8079')
        self.heatSPwhere = opts.get('heatSPwhere', '')
        self.coolSPwhere = opts.get('coolSPwhere', '')
        self.thermwhere = opts.get('thermwhere', '')
        self.tempwhere = opts.get('tempwhere', '')

        print "ZoneController: heat sp where = ", self.heatSPwhere
        print "ZoneController: cool sp where = ", self.coolSPwhere
        print "ZoneController: thermostat where = ", self.thermwhere
        print "ZoneController: temp sensor where = ", self.tempwhere

        self.client = SmapClient(self.archiver_url)

        self.heatSPclient = RepublishClient(self.archiver_url, self.heatSPcb, restrict=self.heatSPwhere)
        self.coolSPclient = RepublishClient(self.archiver_url, self.coolSPcb, restrict=self.coolSPwhere)
        #self.tempclient = RepublishClient(self.archiver_url, self.tempcb, restrict=self.tempwhere)
        self.thermclient = RepublishClient(self.archiver_url, self.thermcb, restrict=self.thermwhere)


    def start(self):
        print "zone controller start: ", self.rate
        self.heatSPclient.connect() # activate subscription scheduler setpoints
        self.coolSPclient.connect() 
        #self.tempclient.connect() 
        self.thermclient.connect() 
        periodicSequentialCall(self.read).start(self.rate)

    def read(self):
        all_readings = self.client.latest(self.tempwhere)
        for p in all_readings:
            print '-'*20
            md = self.client.tags('uuid = "'+p['uuid']+'"')[0]
            print 'Room:', md['Metadata/Room']
            print 'Reading:', p['Readings'][0][1]
            ts = dtutil.ts2dt(p['Readings'][0][0]/1000)
            print 'Time:', dtutil.strftime_tz(ts, tzstr='America/Los_Angeles')
        avg_room_temp = sum([x['Readings'][0][1] for x in all_readings]) / float(len(all_readings))

        # get difference between avg room temperature and thermostat temperature
        new_diff = self.therm_temp - avg_room_temp

        # periodically update output streams.  Here a bogus adjustment
        self.add('/heatSetpoint', self.heatSP + new_diff)
        self.add('/coolSetpoint', self.coolSP + new_diff)
        print "zone controller publish: ", self.heatSP, self.coolSP

    # Event handler for publication to heatSP stream
    def heatSPcb(self, _, data):
        # list of arrays of [time, val]
        print "ZoneController heatSPcb: ", data
        mostrecent = data[-1][-1] 
        self.heatSP = mostrecent[1]

    def coolSPcb(self, _, data):
        # list of arrays of [time, val]
        print "ZoneController coolSPcb: ", data
        mostrecent = data[-1][-1] 
        self.coolSP = mostrecent[1]

    def tempcb(self, _, data):
        # list of arrays of [time, val]
        print "ZoneController tempcb: ", data


    def thermcb(self, _, data):
        # list of arrays of [time, val]
        print "ZoneController thermcb: ", data
        self.therm_temp = data[-1][-1][1]
Example #27
0
from smap.util import periodicSequentialCall
from smap.contrib import dtutil
from smap.util import find
from datetime import timedelta, date

import numpy as np
import pandas as pd
import pdb
import csv
import shutil
import time
import pprint as pp
import datetime

c = SmapClient(base='http://new.openbms.org/backend',\
                               key=['WE4iJWG7k575AluJ9RJyAZs25UO72Xu0b4RA',\
                                    'SA2nYWuHrJxmPNK96pdLKhnSSYQSPdALkvnA'])
t = time.time()
source = 'Brower BACnet'
path_list_and = ['Brower', 'Field_Bus1']
path_list_or=[
             'BrowerAHU2/DA-T',
             'BrowerAHU2/OA-T',
             'BrowerAHU2/SF-value',
             'BrowerAHU2/SF-speed',
             'Plant/Condenser.CWP7-speed',
             'Plant/Condenser.CWP8-speed',
             'Plant/Condenser.CWS-T',
             'Plant/Condenser.CWR-T',
             'Plant/Condenser.HXR-T',
             'Plant/Condenser.HXS-T',
Example #28
0
"""Example code plotting one day's worth of outside air time-series.

@author Stephen Dawson-Haggerty <*****@*****.**>
"""

from smap.archiver.client import SmapClient
from smap.contrib import dtutil

from matplotlib import pyplot
from matplotlib import dates

# make a client
c = SmapClient("http://www.openbms.org/backend")

# start and end values are Unix timestamps
start = dtutil.dt2ts(dtutil.strptime_tz("3-1-2013", "%m-%d-%Y"))
end = dtutil.dt2ts(dtutil.strptime_tz("3-2-2013", "%m-%d-%Y"))

# hard-code the UUIDs we want to download
oat = [
    "395005af-a42c-587f-9c46-860f3061ef0d",
    "9f091650-3973-5abd-b154-cee055714e59",
    "5d8f73d5-0596-5932-b92e-b80f030a3bf7",
    "ec2b82c2-aa68-50ad-8710-12ee8ca63ca7",
    "d64e8d73-f0e9-5927-bbeb-8d45ab927ca5"
]

# perform the download
data = c.data_uuid(oat, start, end)

# plot all the data
Example #29
0
from smap.archiver.client import SmapClient
from datetime import timedelta, date

import sys, os, pdb
import time
import pandas as pd
import numpy as np
import datetime
import math

c = SmapClient(base='http://new.openbms.org/backend')
#               key=['XuETaff882hB6li0dP3XWdiGYJ9SSsFGj0N8'])
uuid_dict = {
    'uuid1': {
        'u': "b7051656-d8d5-53dd-9221-15de4ce84e43",
        'name': "MSA.MAIN.PWR_REAL_3_P"
    },
    'uuid2': {
        'u': "cc1dfe56-3abc-544e-add6-1bc88712fc90",
        'name': "MSB.MAIN.PWR_REAL_3_P"
    }
}
restrict = 'Metadata/SourceName = "Sutardja Dai Hall BACnet" and (uuid ="%s" or uuid = "%s")'\
            %(str(uuid_dict['uuid1']['u']), str(uuid_dict['uuid2']['u']))
#pdb.set_trace()
#TODO: Change Date range here
startF = date(2015, 7, 17)
endF = date(2016, 7, 17)

#Create an empty dataframe to put the data in
dts_startF = time.mktime(startF.timetuple())
import os
import sys
from smap.archiver.client import SmapClient
from VavDataReader import importVavData
import pandas as pd

qStr = 'select Path, uuid where Path like "%S_-%" and Metadata/SourceName = "Sutardja Dai Hall BACnet"'
validVAVs = importVavData(server='http://www.openbms.org/backend', query=qStr)
interpolation_time = '5T'

c = SmapClient("http://new.openbms.org/backend")

outputDir = "Data"
if len(sys.argv) < 2:
    print "No output directory provided. Using default <Data>"
else:
    outputDir = sys.argv[1].strip()

if os.path.exists(outputDir):
    if not os.path.isdir(outputDir):
        print "File with the same name exists. Delete it first"
        exit()
else:
    os.makedirs(outputDir)

startDate = "6/08/2015"
endDate = "6/09/2015"

numRooms = len(validVAVs)
count = 0
for room in validVAVs:
Example #31
0
from smap.archiver.client import SmapClient
from smap.contrib import dtutil

import pdb, time, datetime
import numpy as np
import pdb
import smtplib
import pprint as pp

c = SmapClient("http://new.openbms.org/backend")
t = time.time()
source = 'Sutardja Dai Hall TAV'
error_uuid_list = ['36335391-49a6-5b21-9f00-fcce66eb5a74']
N = len(error_uuid_list)
where = "Metadata/SourceName = '%s' and (" %(source)\
                    + ' or\n '.join(["uuid = '%s'"] * N) \
                    %tuple(error_uuid_list) + ")"
tags = c.tags(where)
error_dict = {}
error_list = [[1441431059000.0, 1.0], [1441430819000.0, 1.0]]
#error_list = [[1441605186000.0, 0.0]]
pp.pprint(error_list)
for tag in tags:
    name = str(tag['Path'].split('/')[1])
    u = str(tag['uuid'])
    if name not in error_dict:
        error_dict[name] = {}
        if u not in error_dict[name]:
            error_dict[name]['uuid'] = u
            error_dict[name]['Readings'] = []
Example #32
0
import os
import sys
from smap.archiver.client import SmapClient
from smap.contrib import dtutil
import re
import json

c = SmapClient("http://new.openbms.org/backend",
               key="NAXk19YY45TTiXlajiQGQ8KTp283oHfp2Uly")
rooms = c.query("select distinct Metadata/room-id where Metadata/site='STA'")
metadata = {}
count = 0
numRooms = len(rooms)
for room in rooms:
    count += 1
    print "Building Metadata for room : %s (%d/%d)" % (room, count, numRooms)
    metadata[room] = {}
    sensors = c.query("select * where Metadata/room-id='" + str(room) +
                      "' and Metadata/site='STA'")
    for i in range(len(sensors)):
        if "Name" not in sensors[i]["Metadata"]:
            continue
        pointName = sensors[i]["Metadata"]["Name"]
        roomMetadata = sensors[i]["Metadata"]

        if "room_temp" in roomMetadata:
            metadata[room]["room_temp"] = pointName
        if "supply_air_velocity" in roomMetadata or "supply_air_volume" in roomMetadata:
            metadata[room]["supply_air_velocity"] = pointName
        if "reheat_valve_position" in roomMetadata:
            metadata[room]["reheat_valve_position"] = pointName
Example #33
0
import os
import sys
from smap.archiver.client import SmapClient
from smap.contrib import dtutil
import re
import json

inf = open("room_metadata")
roomMetadata = json.load(inf)

c = SmapClient("http://new.openbms.org/backend")

outputDir = "data"
if len(sys.argv) < 2:
    print "No output directory provided. Using default <data>"
else:
    outputDir = sys.argv[1].strip()

if os.path.exists(outputDir):
    if not os.path.isdir(outputDir):
        print "File with the same name exists. Delete it first"
        exit()
else:
    os.makedirs(outputDir)

startDate = "05/27/2015"
endDate = "07/04/2015"

numRooms = len(roomMetadata)
count = 0
for room in roomMetadata:
Example #34
0
            'S5-14', 'S5-16', 'S5-18', 'S5-19', 'S5-20', 'S5-21',
            'S6-01', 'S6-02', 'S6-03', 'S6-04', 'S6-05', 'S6-06',
            'S6-07', 'S6-08', 'S6-10', 'S6-11', 'S6-12', 'S6-13',
            'S6-15', 'S6-17', 'S6-18', 'S6-19', 'S6-20', 'S7-01',
            'S7-02', 'S7-03', 'S7-04', 'S7-05', 'S7-06', 'S7-07',
            'S7-08', 'S7-09', 'S7-10', 'S7-13', 'S7-14', 'S7-15',
            'S7-16'
           ]
rh_coils = dict(zip(rh_coils,[2.0]*len(rh_coils)*pq.F))
rh_stream_names = []
for name in rh_coils:
  rh_stream_names += ['coil_closed_temp_change_' + name] + \
                     ['hot_water_' + name] + \
                     ['instantaneous_zone_load_' + name]

c = SmapClient(base='http://new.openbms.org/backend',\
               key='XuETaff882hB6li0dP3XWdiGYJ9SSsFGj0N8')

# Query necessary tags for energy data
source_energy = 'Sutardja Dai Hall Energy Data'
all_points = pointnames + rh_stream_names + chw_stream_names
where_energy = "Metadata/SourceName = '%s' and Path ~ '%s' and (" \
                 %(source_energy, p)\
                 + ' or '.join(["Path ~ '%s'"] * len(all_points))\
                 %tuple(all_points) + ")"
tags_energy = c.tags(where_energy)

# Query data for energy calcs as AHU level
source = 'Sutardja Dai Hall BACnet'
path_list = {
                'AH2A_SF_VFD' : 'SDH/AH2A/SF_VFD:POWER',
                'AH2B_SF_VFD' : 'SDH/AH2B/SF_VFD:POWER',
Example #35
0
"""Example code plotting one day's worth of outside air time-series,
locating the streams using a metadata query.

@author Stephen Dawson-Haggerty <*****@*****.**>
"""

from smap.archiver.client import SmapClient
from smap.contrib import dtutil

from matplotlib import pyplot
from matplotlib import dates

# make a client
c = SmapClient("http://www.openbms.org/backend")

# start and end values are Unix timestamps
start = dtutil.dt2ts(dtutil.strptime_tz("1-1-2013", "%m-%d-%Y"))
end   = dtutil.dt2ts(dtutil.strptime_tz("1-2-2013", "%m-%d-%Y"))

# download the data and metadata
tags = c.tags("Metadata/Extra/Type = 'oat'")
uuids, data = c.data("Metadata/Extra/Type = 'oat'", start, end)

# make a dict mapping uuids to data vectors
data_map = dict(zip(uuids, data))

# plot all the data
for timeseries in tags:
  d = data_map[timeseries['uuid']]
  # since we have the tags, we can add some metadata
  label = "%s (%s)" % (timeseries['Metadata/SourceName'],
Example #36
0
"""Example code plotting one day's worth of outside air time-series.

@author Stephen Dawson-Haggerty <*****@*****.**>
"""

from smap.archiver.client import SmapClient
from smap.contrib import dtutil

from matplotlib import pyplot
from matplotlib import dates

# make a client
c = SmapClient("http://www.openbms.org/backend")

# start and end values are Unix timestamps
start = dtutil.dt2ts(dtutil.strptime_tz("3-1-2013", "%m-%d-%Y"))
end   = dtutil.dt2ts(dtutil.strptime_tz("3-2-2013", "%m-%d-%Y"))

# hard-code the UUIDs we want to download
oat = [
  "395005af-a42c-587f-9c46-860f3061ef0d", 
  "9f091650-3973-5abd-b154-cee055714e59", 
  "5d8f73d5-0596-5932-b92e-b80f030a3bf7", 
  "ec2b82c2-aa68-50ad-8710-12ee8ca63ca7", 
  "d64e8d73-f0e9-5927-bbeb-8d45ab927ca5"
]

# perform the download
data = c.data_uuid(oat, start, end)

# plot all the data
Example #37
0
"""
sum up the feeds of energy consumption from a building and apply EMD to the sum
@author: Dezhi
"""
import urllib2
import numpy as np
import matplotlib.pyplot as plt
import time
import csv
from smap.archiver.client import SmapClient
from smap.contrib import dtutil
from EMDpython import EMD
from temp import get_temp

# make a client
c = SmapClient("http://new.openbms.org/backend")

# get the components for query
bldg_list = [i.strip('\n') for i in open('bldg_list.txt', 'r').readlines()]
index = range(1,len(bldg_list))
bldg_dict = dict(zip(index, bldg_list))
print "================================================"
print "\n".join(["%s-%s" %(k,v) for k,v in bldg_dict.items()])

num = raw_input("choose a # from above to query: ")
bldg = bldg_dict[int(num)]
# start = raw_input("start time (\"%m-%d-%Y %H:%M\" or "-d" for default): ")
# end = raw_input("end time (\"%m-%d-%Y %H:%M\") or "-d" for default: ")
start = "10-21-2013 00:00"
end = "10-27-2013 23:59"
# get the outside air temperature during the period specified
              %(str(f).zfill(2), str(zone_name))
              + '%s-%s_demo_temp.csv'%(start.strftime("%Y%m%d"), end.strftime("%Y%m%d")))
        #pdb.set_trace()
        #Combine all zones (columns) in a dataframe
        #TODO: create a temp file with aggregated floors
        df_floor = reduce(lambda x,y: \
                   pd.merge(x, y, on=['timestamp','datetime']),floor_frames)
        #+ 'Floor%s_airflow_temp_load' %(str(f).zfill(2))  \
        #TODO: change file name HERE
        floor_path = floor_dir \
            + 'Floor%s_demo' %(str(f).zfill(2))\
            + '%s-%s'%(startF.strftime("%Y%m%d"), endFp.strftime("%Y%m%d"))\
            + '.csv'
        df_floor.to_csv(floor_path)

c = SmapClient(base='http://new.openbms.org/backend',\
                 key=['XuETaff882hB6li0dP3XWdiGYJ9SSsFGj0N8'])
source = 'Sutardja Dai Hall BACnet'
source_tav = 'Sutardja Dai Hall TAV'
source_energy = 'Sutardja Dai Hall Energy Data'
path_and_tav = ['tav_whole_bldg/']
path_and_energy = ['energy_data/', 'variable_elec_cost/']
#TODO : include points we want
#points = ['CTL_FLOW_MAX', 'CTL_FLOW_MIN', 'AIR_VOLUME'] #, 'ROOM_TEMP', 'CTL_STPT']
points = [
    'AIR_VOLUME', 'CTL_FLOW_MIN', 'CLG_LOOPOUT', 'HTG_LOOPOUT', 'DMPR_POS',
    'DMPR_CMD'
]
#points_tav = ['/cycle']
points_tav = [
    'average_airflow_in_cycle', 'average_airflow_in_hour', 'tav_active'
]
import os
import sys
from smap.archiver.client import SmapClient
from smap.contrib import dtutil
import re
import json

c = SmapClient("http://new.openbms.org/backend", key="NAXk19YY45TTiXlajiQGQ8KTp283oHfp2Uly")
rooms = c.query("select distinct Metadata/room-id where Metadata/site='STA'")
metadata = {}
count = 0
numRooms = len(rooms)
for room in rooms:
	count += 1
	print "Building Metadata for room : %s (%d/%d)" % (room, count, numRooms )
	metadata[room] = {}
	sensors = c.query("select * where Metadata/room-id='" + str(room) + "' and Metadata/site='STA'")
	for i in range(len(sensors)):
		if "Name" not in sensors[i]["Metadata"]:
			continue
		pointName = sensors[i]["Metadata"]["Name"]
		roomMetadata = sensors[i]["Metadata"]
			
		if "room_temp" in roomMetadata:
			metadata[room]["room_temp"] = pointName
		if "supply_air_velocity" in roomMetadata or "supply_air_volume" in roomMetadata:
			metadata[room]["supply_air_velocity"] = pointName
		if "reheat_valve_position" in roomMetadata:
			metadata[room]["reheat_valve_position"] = pointName

Example #40
0
from smap.archiver.client import SmapClient
from smap.contrib import dtutil

from matplotlib import pyplot
from matplotlib import dates
import os
import re
import json
import ast
from datetime import datetime

# make a client
c = SmapClient("http://new.openbms.org/backend")

# get tag list
#tag = [i.strip('\n') for i in open('tagList.txt', 'r').readlines()]
stnc = "select distinct Path"
result = c.query(stnc)

outFile = open("MetadataDump","w")
finalStructure = {}
count = 0
lastTime = datetime.now()
print len(result)
print "Experiment started at : ",lastTime
for tag in result:
	queryString = "select * where Path='" + tag + "'"
	out = c.query(queryString)
	#finalStructure[tag] = out[0]
	count += 1
	if count % 100 == 0:
Example #41
0
@authour Shuyang Li <*****@*****.**>
"""
from smap.archiver.client import SmapClient
from smap.contrib import dtutil

import datetime, time, pdb, re
import numpy as np
import quantities as pq

from matplotlib import pyplot
from matplotlib import dates

##t = time.time()
t = time.strptime("30 Nov 15 23 40 00", "%d %b %y %H %M %S")
t = time.mktime(t)
c = SmapClient("http://www.openbms.org/backend")
source = "Metadata/SourceName = 'Sutardja Dai Hall BACnet'"
where = source + " and Path ~ 'S[0-9]-[0-9][0-9]' and" +\
        "(Path ~ 'CLG_LOOPOUT' or Path ~ 'HTG_LOOPOUT' or " +\
        "Path ~ 'AIR_VOLUME' or Path ~ 'VLV_POS' or " +\
        "Path ~ 'AI_3' or Path ~ '')"
tags = c.tags(where)
data = c.prev(where, t, streamlimit=1000, limit=1000)
vavs_rhv = [] # vav with reheat valve
vavs_rhv = ['S1-01', 'S1-02', 'S1-03', 'S1-04', 'S1-07', 'S1-08', 'S1-09', 'S1-10', 'S1-13', 'S1-15', 'S1-16', 'S1-17', 'S1-18', 'S1-19', 'S1-20', 'S2-01', 'S2-02', 'S2-03', 'S2-04', 'S2-05', 'S2-06', 'S2-07', 'S2-10', 'S2-11', 'S2-12', 'S2-13', 'S2-14', 'S2-15', 'S2-16', 'S2-17', 'S2-18', 'S2-19', 'S2-20', 'S2-21', 'S3-01', 'S3-02', 'S3-03', 'S3-04', 'S3-05', 'S3-06', 'S3-07', 'S3-08', 'S3-09', 'S3-10', 'S3-11', 'S3-12', 'S3-15', 'S3-16', 'S3-17', 'S3-18', 'S3-19', 'S3-20', 'S3-21', 'S4-01', 'S4-02', 'S4-03', 'S4-04', 'S4-05', 'S4-06', 'S4-07', 'S4-08', 'S4-09', 'S4-11', 'S4-12', 'S4-13', 'S4-15', 'S4-16', 'S4-18', 'S4-19', 'S4-20', 'S4-21', 'S5-01', 'S5-02', 'S5-03', 'S5-04', 'S5-05', 'S5-06', 'S5-07', 'S5-08', 'S5-09', 'S5-10', 'S5-11', 'S5-12', 'S5-13', 'S5-14', 'S5-16', 'S5-18', 'S5-19', 'S5-20', 'S5-21', 'S6-01', 'S6-02', 'S6-03', 'S6-04', 'S6-05', 'S6-06', 'S6-07', 'S6-08', 'S6-10', 'S6-11', 'S6-12', 'S6-13', 'S6-15', 'S6-17', 'S6-18', 'S6-19', 'S6-20', 'S7-01', 'S7-02', 'S7-03', 'S7-04', 'S7-05', 'S7-06', 'S7-07', 'S7-08', 'S7-09', 'S7-10', 'S7-13', 'S7-14', 'S7-15', 'S7-16']


for v in sorted(vavs_rhv):
    u_rhv = [tag['uuid'] for tag in tags if v in tag['Path'] and 'VLV_POS' in tag ['Path']]
    u_ht = [tag['uuid'] for tag in tags if v in tag['Path'] and 'HTG_LOOPOUT' in tag ['Path']]    
    u_dat = [tag['uuid'] for tag in tags if v in tag['Path'] and 'AI_3' in tag ['Path']]
Example #42
0
OF THE POSSIBILITY OF SUCH DAMAGE.
"""
"""
Keti mote protocol implementation and sMAP driver.

@author Stephen Dawson-Haggerty <*****@*****.**>
"""

import datetime

from smap.archiver.client import SmapClient
from smap.contrib import dtutil
import numpy as np
import matplotlib.pyplot as plt

c = SmapClient('http://ar1.openbms.org:8079')

HOURS = 5
RATES = [#("#", 10), 
         ("ppm", 5), ("C", 5)]

prrs = []
for unit, rate in RATES:
    counts = c.query(("apply count to data in now -%ih, now "
                      "limit -1 streamlimit 1000 where "
                      "Properties/UnitofMeasure = '%s' and "
                      "Metadata/SourceName = 'KETI Motes'") %
                     (HOURS, unit))
    for v in counts:
        r = np.array(v['Readings'])
        if len(r):
Example #43
0
 def load_tags(self):
     """Load the matching tags (in a thread)"""
     c = SmapClient(self.source_url)
     return c.tags(self.restrict)
Example #44
0



    return inputs



class ProcessOperator(operators.ParallelSimpleOperator):
    base_operator = staticmethod(thetaprobe)
    name = 'movingavg-'
    operator_name = 'movingavg'
    operator_constructors = [(),
                             (int,)]
    def __init__(self, inputs, lag=10):
        self.name = 'movingavg-' + str(lag)
        operators.ParallelSimpleOperator.__init__(self, inputs, lag=lag)


### test ###
c=SmapClient()
inputs=c.data_uuid()

# hist=null
inputs = np.array(inputs, dtype=float)
data = np.vstack(inputs)


nd=thetaprobe(inputs)

RepublishClient()
Example #45
0
 def __init__(self,login):
     """"""
     self.c = SmapClient("http://%(host)s:%(port)s" % login)
Example #46
0
from smap.archiver.client import SmapClient
from smap.contrib import dtutil
import numpy as np
import pandas as pd
import datetime
import subprocess

#Link to download the data
c = SmapClient("http://iiitdarchiver.zenatix.com:9105")

#Range of dates to which you want to download the data

start = dtutil.dt2ts(dtutil.strptime_tz("01-10-2017", "%d-%m-%Y"))
end = dtutil.dt2ts(dtutil.strptime_tz("01-10-2017", "%d-%m-%Y"))

# hard-code the UUIDs we want to download
oat = ["eec41258-f057-591e-9759-8cfdeb67b9af"]

# Function to perform the download of the data
data = c.data_uuid(oat, start, end)

t = np.array(data)
df = pd.DataFrame(t)

# creating files after downloading
for i, j in enumerate(t):
    name = str(i) + '.csv'
    with open(name, 'w') as f:
        for time, val in j:
            f.write(
                str(datetime.datetime.fromtimestamp(time / 1000.0)) + ' , ' +
Example #47
0
from smap.contrib import dtutil
from sklearn.tree import DecisionTreeClassifier as DT

import numpy as np
import os

def get_feature(data):
	mean = np.mean(data)
	median = np.median(data)
	std = np.std(data)
	q1 = np.percentile(data,25)	
	q3 = np.percentile(data,75)
	vector = [mean, median, std, q1, q3]
	return vector

c = SmapClient("http://new.openbms.org/backend")
lines = open('MetadataDump').readlines()
sdh_path = [i.strip('\n') for i in open('sdh_path','r').readlines()]

search_path = []
search_res = []
res = keywordSearch(lines, "sdh temp", 2000)
water = keywordSearch(lines, "sdh hw temp", 1000)
stp = keywordSearch(lines, "sdh temp stp", 1000)
search = keywordSearch(lines, "sdh room temp", 2000)
add = keywordSearch(lines, "sdh rm temp", 1000)
for i in water:
	res.remove(i)
for i in stp:
	res.remove(i)
for r in res:
Example #48
0
from smap.archiver.client import SmapClient
from smap.contrib import dtutil

from matplotlib import pyplot
from matplotlib import dates
import os
# make a client
c = SmapClient("http://new.openbms.org/backend")

# start and end values are Unix timestamps
t_start = "6-12-2013 8:00"
t_end = "6-19-2013 8:00"
start = 1000*dtutil.dt2ts(dtutil.strptime_tz(t_start, "%m-%d-%Y %H:%M"))
end   = 1000*dtutil.dt2ts(dtutil.strptime_tz(t_end, "%m-%d-%Y %H:%M"))

stnc = "select distinct Metadata/Location/RoomNumber where Metadata/SourceName='KETI Motes'"
roomlist = c.query(stnc) #the result is a list

#roomlist = roomlist[16:]
#roomlist = ['621A','621B','621C','621D','621E']
for room in roomlist:
	print "==========Fetching streams in Room %s=========="%room
	stnc = "select Path where Metadata/Location/RoomNumber='%s' and not Path ~ '.*pir.*'" %room
	streams = c.query(stnc)
	if len(streams)>0:
		# print "----%d streams in Room %s----"%(len(streams), room)

		for s in streams:
			# fetch the metadata of path wanted
			tags = c.tags("Path='%s'"%s['Path'])
Example #49
0
from smap.archiver.client import SmapClient
import time
import datetime
import json
import pandas as pd
#pd.options.display.mpl_style = 'default'

client = SmapClient('http://ciee.cal-sdb.org:8079')
# timestamps
end = int(time.time())
#start = end - 60*60*24*30 # last month
start = end - 60 * 60 * 24 * 7  # last week

zones = client.query('select distinct Metadata/HVACZone')


def getdataasjson(query, start, end):
    tmp_data = client.data(query, start, end, cache=True, limit=500000)
    if not len(tmp_data[0]):
        return {}
    tmp = pd.DataFrame(tmp_data[1][0])
    if len(tmp.notnull()) == 0:
        return {}
    tmp = tmp[pd.np.abs(tmp[1] - tmp[1].mean()) <= 5 * tmp[1].std()]
    tmp[0] = pd.to_datetime(tmp[0], unit='ms')
    tmp.index = tmp[0]
    tmp = tmp.drop_duplicates()
    del tmp[0]
    return json.loads(tmp.to_json())["1"]