269 lines
9.6 KiB
Plaintext
269 lines
9.6 KiB
Plaintext
import time
|
|
from collections import OrderedDict
|
|
Logger = system.util.getLogger("reports.MBR.coolingdata")
|
|
|
|
def test1_0():
|
|
res={}
|
|
endDate= system.date.midnight(system.date.now())
|
|
startDate = system.date.addDays(endDate, -2)
|
|
tempDS, humDS = reports.MBR.coolingdata.getRawDataMeasurement(startDate, endDate, "DH1", customArgs= {"noInterpolation":False})
|
|
# res["tempDS"]= tempDS
|
|
# res["humDS"] = humDS
|
|
# group the sensors by aisle then perform an interval average
|
|
tempDS = reports.MBR.common.util.averageIntervalData(groupColumnLocation(tempDS, "Temp"), 60)
|
|
humDS = reports.MBR.common.util.averageIntervalData(groupColumnLocation(humDS, "Humidity"), 60)
|
|
|
|
|
|
tempSummaryDS = reports.MBR.coolingdata.generateSummaryColumnDS(tempDS, "Temp")
|
|
humiditySummaryDS = reports.MBR.coolingdata.generateSummaryColumnDS(humDS, "Humidity")
|
|
summaryDS = combineTempHumidity(tempSummaryDS, humiditySummaryDS)
|
|
del tempSummaryDS
|
|
del humiditySummaryDS
|
|
|
|
|
|
measurementDS = reports.MBR.common.util.mergeHistorianData(combineTempHumidity(tempDS, humDS),summaryDS)
|
|
res["measurementDS"]=measurementDS
|
|
res["summaryDS"]=summaryDS
|
|
return res
|
|
|
|
|
|
def genSummCols(ds, snsrType, aggRow):
|
|
if aggRow:
|
|
return reports.MBR.coolingdata.generateSummaryColumnDS(ds, snsrType)
|
|
else:
|
|
return reports.MBR.coolingdata.generateRangeSummaryCol(ds, snsrType)
|
|
def doReport(startDate, endDate, locations, intervalTime = 60, aggRow= True):
|
|
"""
|
|
Args:
|
|
aggRow boolean, true: get the min/max/avg on row, false: get the min max over the range, and avg per row
|
|
"""
|
|
res={}
|
|
customArgs= {"noInterpolation":False}
|
|
tempDS, humDS = None, None
|
|
if locations is None:
|
|
tempDS, humDS = reports.MBR.coolingdata.getRawDataMeasurement(startDate, endDate, None,customArgs)
|
|
else:
|
|
for loc in locations:
|
|
ds1, ds2 = getRawDataMeasurement(startDate, endDate, loc, customArgs)
|
|
if tempDS is None and humDS is None:
|
|
tempDS = ds1
|
|
humDS = ds2
|
|
else:
|
|
tempDS= reports.MBR.common.util.mergeHistorianData(tempDS, ds1)
|
|
humDS= reports.MBR.common.util.mergeHistorianData(humDS, ds1)
|
|
# res["tempDS"]= tempDS
|
|
# res["humDS"] = humDS
|
|
# group the sensors by aisle then perform an interval average
|
|
tempDS = reports.MBR.common.util.averageIntervalData(groupColumnLocation(tempDS, "Temp"), intervalTime)
|
|
humDS = reports.MBR.common.util.averageIntervalData(groupColumnLocation(humDS, "Humidity"), intervalTime)
|
|
|
|
|
|
tempSummaryDS = genSummCols(tempDS, "Temp", aggRow)
|
|
humiditySummaryDS = genSummCols(humDS, "Humidity", aggRow)
|
|
summaryDS = combineTempHumidity(tempSummaryDS, humiditySummaryDS)
|
|
del tempSummaryDS
|
|
del humiditySummaryDS
|
|
|
|
|
|
measurementDS = addStaticLimits(reports.MBR.common.util.mergeHistorianData(combineTempHumidity(tempDS, humDS),summaryDS))
|
|
res["measurementDS"]=measurementDS
|
|
res["summaryDS"]=summaryDS
|
|
return res
|
|
|
|
def doReport2(startDate, endDate, locations, intervalTime = 60, aggRow= False):
|
|
"""
|
|
Args:
|
|
aggRow boolean, true: get the min/max/avg on row, false: get the min max over the range, and avg per row
|
|
"""
|
|
tSt = time.time()
|
|
res={}
|
|
customArgs= {"noInterpolation":False}
|
|
superTempDS, superHumDS, tempDS, humDS = None, None, None, None
|
|
if locations is None:
|
|
locations = ["DH1","DH2","DH3","DH4","DH5"]
|
|
summaryRows = []
|
|
|
|
|
|
for loc in locations:
|
|
ds1, ds2 = getRawDataMeasurement(startDate, endDate, loc, customArgs)
|
|
tempDS = ds1
|
|
humDS = ds2
|
|
if superTempDS is None and superHumDS is None:
|
|
superTempDS = ds1
|
|
superHumDS = ds2
|
|
else:
|
|
superTempDS= reports.MBR.common.util.mergeHistorianData(superTempDS, ds1)
|
|
superHumDS= reports.MBR.common.util.mergeHistorianData(superHumDS, ds2)
|
|
tempDS = reports.MBR.common.util.averageIntervalData(groupColumnLocation(tempDS, "Temp"), intervalTime)
|
|
humDS = reports.MBR.common.util.averageIntervalData(groupColumnLocation(humDS, "Humidity"), intervalTime)
|
|
|
|
|
|
|
|
tempSummaryDS = genSummCols(tempDS, "Temp", aggRow)
|
|
humiditySummaryDS = genSummCols(humDS, "Humidity", aggRow)
|
|
summaryDS = combineTempHumidity(tempSummaryDS, humiditySummaryDS)
|
|
del tempSummaryDS
|
|
del humiditySummaryDS
|
|
summaryRows.append([loc.replace("DH", "Datahall "), system.dataset.toDataSet(summaryDS) ])
|
|
print "elapsed 1: ", time.time() - tSt
|
|
|
|
# group the sensors by aisle then perform an interval average
|
|
print "elapsed 2: ", time.time()- tSt
|
|
superTempDS = reports.MBR.common.util.averageIntervalData(groupColumnLocation(superTempDS, "Temp"), intervalTime)
|
|
superHumDS = reports.MBR.common.util.averageIntervalData(groupColumnLocation(superHumDS, "Humidity"), intervalTime)
|
|
tempSummaryDS = genSummCols(superTempDS, "Temp", aggRow)
|
|
humiditySummaryDS = genSummCols(superHumDS, "Humidity", aggRow)
|
|
summaryDS = combineTempHumidity(tempSummaryDS, humiditySummaryDS)
|
|
measurementDS = addStaticLimits(reports.MBR.common.util.mergeHistorianData(combineTempHumidity(superTempDS, superHumDS),summaryDS))
|
|
print "elapsed 3: ", time.time()- tSt
|
|
|
|
res["summaryDS"]=summaryDS
|
|
res["measurementDS"]=measurementDS
|
|
res["locSummaryDS"] = system.dataset.toDataSet(["Location", "data"], summaryRows)
|
|
return res
|
|
# res["summaryDS"]=system.dataset.toDataSet([],summaryDS)
|
|
def getRawDataMeasurement(startDate, endDate, location, customArgs= {}):
|
|
"""
|
|
Get the history 1-minute interval for the relevant location sensors
|
|
Args:
|
|
startDate: datetime
|
|
endDate: datetime
|
|
location: str DH1, DH2..
|
|
customArgs: optional overrides for the history retrieval
|
|
Returns:
|
|
tuple (temp Dataset, humidity dataset)
|
|
"""
|
|
logger = Logger.createSubLogger("getRawDataMeasurement")
|
|
stTime= time.time()
|
|
tempTags = reports.MBR.common.coolingTags.generateTags(location, "temp")
|
|
humidityTags = reports.MBR.common.coolingTags.generateTags(location, "humidity")
|
|
|
|
tempDS = reports.MBR.common.util.getHistory(tempTags, startDate, endDate, customArgs)
|
|
humidityDS = reports.MBR.common.util.getHistory(humidityTags, startDate, endDate, customArgs)
|
|
logger.debug("complete duration: %s"%(time.time()-stTime))
|
|
|
|
return tempDS, humidityDS
|
|
|
|
|
|
|
|
def groupColumnLocation(histDS, sensorType):
|
|
"""
|
|
Take the full range of tag columns and group them by location and average the value
|
|
ex. [Ignition_Common_IO_Gtwy]DH1/SATB1_DH1_PNL24_C1_HT01/Val
|
|
[Ignition_Common_IO_Gtwy]DH1/SATB1_DH1_PNL24_C1_HT02/Val
|
|
[Ignition_Common_IO_Gtwy]DH1/SATB1_DH1_PNL24_C1_HT03/Val
|
|
becomes DH1_C1
|
|
Args:
|
|
histDS: pyds of history
|
|
sensorType: str Temp/Humidity
|
|
Returns:
|
|
py dataset
|
|
"""
|
|
def groupColNames(colNames):
|
|
colMap = OrderedDict()
|
|
for name in colNames:
|
|
|
|
cNameParts = name.split("/")[1].split("_")
|
|
gName = "%s_%s %s"%(cNameParts[1], cNameParts[3], sensorType)
|
|
colMap.setdefault(gName, [])
|
|
colMap[gName].append(name)
|
|
return colMap
|
|
|
|
oColNames = system.dataset.getColumnHeaders(histDS)[1:]
|
|
colMap = groupColNames(oColNames)
|
|
newCols = colMap.keys()
|
|
|
|
# now let's average across the new names
|
|
allRows = []
|
|
for row in histDS:
|
|
oneRow = [row["t_stamp"]]
|
|
for grp in newCols:
|
|
groupVals = [row[c] for c in colMap[grp]]
|
|
try:
|
|
oneRow.append(sum(groupVals)/len(groupVals))
|
|
except:
|
|
oneRow.append(-1.0)
|
|
|
|
allRows.append(oneRow)
|
|
|
|
return system.dataset.toPyDataSet(system.dataset.toDataSet(["t_stamp"]+newCols , allRows))
|
|
|
|
def combineTempHumidity(tempDS, humidityDS):
|
|
"""
|
|
Build the custom column sort order C1 Humidity, C1 Temp, C2 Humidity, etc..
|
|
Args:
|
|
tempDS: pyDataset
|
|
humidityDS: humidityDS
|
|
Returns:
|
|
pydataset
|
|
"""
|
|
allRows = []
|
|
header = ["t_stamp"]
|
|
tempHeaders = system.dataset.getColumnHeaders(tempDS)
|
|
humHeaders = system.dataset.getColumnHeaders(humidityDS)
|
|
|
|
for rCnt, row in enumerate(humidityDS):
|
|
newRow = [row["t_stamp"]]
|
|
for cCnt in range(1, len(row)):
|
|
if rCnt == 0:
|
|
header.extend([humHeaders[cCnt], tempHeaders[cCnt]])
|
|
newRow.extend([row[cCnt], tempDS[rCnt][cCnt]])
|
|
allRows.append(newRow)
|
|
# print header, len(header), len(allRows[0])
|
|
return system.dataset.toPyDataSet(system.dataset.toDataSet(header, allRows))
|
|
|
|
|
|
def generateSummaryColumnDS(ds1, sensorType):
|
|
"""
|
|
Receive the grouped dataset and calculate the Min/Max/Avg/Limit for each row
|
|
Args:
|
|
ds1: pydataset grouped by sensors
|
|
sensorType: str (Temp or Humidity)
|
|
Returns:
|
|
pydataset with columns t_stamp, Max , Avg, Min
|
|
"""
|
|
header = ["t_stamp", "Max %s"%(sensorType), "Avg %s"%(sensorType), "Min %s"%(sensorType)]
|
|
allRows = []
|
|
for row in ds1:
|
|
rowVals= [c for c in row[1:]]
|
|
allRows.append([row["t_stamp"], max(rowVals), sum(rowVals)/len(rowVals), min(rowVals)])
|
|
return system.dataset.toPyDataSet(system.dataset.toDataSet(header, allRows))
|
|
|
|
|
|
def generateRangeSummaryCol(ds1, sensorType):
|
|
"""
|
|
Receive the grouped dataset and calculate the Min/Max/Avg/Limit for the entire range
|
|
Args:
|
|
ds1: pydataset grouped by sensors
|
|
sensorType: str (Temp or Humidity)
|
|
Returns:
|
|
pydataset with columns t_stamp, Max , Avg, Min
|
|
"""
|
|
header = ["t_stamp", "Max %s"%(sensorType), "Avg %s"%(sensorType), "Min %s"%(sensorType)]
|
|
allRows = []
|
|
vals = []
|
|
for row in ds1:
|
|
vals.extend([v for v in row[1:]])
|
|
rowVals= [c for c in row[1:]]
|
|
allRows.append([row["t_stamp"], None, sum(rowVals)/len(rowVals), None])
|
|
valMin = min(vals)
|
|
valMax = max(vals)
|
|
for sRow in allRows:
|
|
sRow[1] = valMax
|
|
sRow[3] = valMin
|
|
|
|
return system.dataset.toPyDataSet(system.dataset.toDataSet(header, allRows))
|
|
|
|
def addStaticLimits(ds):
|
|
limits= []
|
|
limits.append( [reports.MBR.common.static.humidityHighLimit for i in range(len(ds))])
|
|
limits.append( [reports.MBR.common.static.humidityLowLimit for i in range(len(ds))])
|
|
limits.append( [reports.MBR.common.static.tempHighLimit for i in range(len(ds))])
|
|
limits.append( [reports.MBR.common.static.tempLowLimit for i in range(len(ds))])
|
|
|
|
for i,cName in enumerate(["Hum High Lim", "Hum Low Lim", "Temp High Lim", "Temp Low Lim"]):
|
|
ds = system.dataset.addColumn(ds, limits[i], cName, float)
|
|
|
|
return system.dataset.toPyDataSet(ds)
|
|
|
|
|