def writeAtiMelt(selectedList, dList, aList, mList):
# print '\n#----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#'
# print '#Begin Creating ATI and Melt-CUM DSS paths'
# print '#----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#'
for ab, d, a, m in zip(selectedList, dList, aList, mList):
aPart = ab.split("/")[1]
b = ab.split("/")[2]
# print 'aPart: ', aPart
# ATI-MELT DSS path Created
tsATI = TimeSeriesContainer()
tsATI.watershed = aPart
tsATI.location = b
tsATI.parameter = 'ATI'
# F-part will be 'CALC'
tsATI.version = 'CALC'
# Interval is hard coded as 1Day = 1440 minutes.
tsATI.interval = 1440
tsATI.fullName = '/%s/%s/%s//1DAY/%s/' % \
(aPart, b, 'ATI', 'CALC')
tsATI.values = a
times = []
hecTime = HecTime()
for i, v in enumerate(d):
hecTime.set(d[i])
times.append(hecTime.value())
tsATI.times = times
tsATI.startTime = times[0]
tsATI.endTime = times[-1]
tsATI.numberValues = len(a)
tsATI.units = 'DEGF-DAY'
tsATI.type = 'INST-VAL'
dssFile.put(tsATI)
# MELT-CUM DSS path Created
tsMelt = TimeSeriesContainer()
tsMelt.watershed = aPart
tsMelt.location = b
tsMelt.parameter = 'MELT-CUM'
tsMelt.version = 'CALC'
# Interval and FullName are hard coded as 1Day = 1440 minutes.
tsMelt.interval = 1440
tsMelt.fullName = '/%s/%s/%s//1DAY/%s/' % \
(aPart, b, 'MELT-CUM', 'CALC')
tsMelt.values = m
tsMelt.times = times
tsMelt.startTime = times[0]
tsMelt.endTime = times[-1]
tsMelt.numberValues = len(m)
tsMelt.units = 'IN'
tsMelt.type = 'INST-VAL'
dssFile.put(tsMelt)
def reformatForecast(fcstTSC):
# converts dailies to forecast set;
# converts irregular data with monthly 0s to standard CRT format.
# iterate through values
outTimes = []
outVals = []
firstPoint = True
prevTime, prevVal = 0, Constants.UNDEFINED
isIrregular = (fcstTSC.interval <= 0)
for t,v in zip(fcstTSC.times, fcstTSC.values):
# add end point from previous when this changes; then start with new value
ht = HecTime()
ht.set(t)
prevHt = HecTime()
prevHt.set(prevTime)
# insert new point whenever it changes, month changes, or on the first point
if firstPoint or v != prevVal or (ht.month() != prevHt.month() and v != 0):
# output endtimestamp for previous value
if not firstPoint:
outTimes.append(prevTime)
outVals.append(prevVal)
if firstPoint:
firstPoint = False
# output start timestamp for this value
offset = -(24*60) + 1 # default to one minute past 0000 this day.
if isIrregular and ht.minute() != 0:
offset = 0
outTimes.append(t + offset)
outVals.append(v)
prevTime = t
prevVal = v
# add last value to finish out series.
#outTimes.append(t)
#outVals.append(v)
# create output TSC
fcstOutTSC = TimeSeriesContainer()
fcstOutTSC.interval = -1
newPathName = fcstTSC.fullName.split("/")
if not isIrregular:
newPathName[5] = "IR-CENTURY"
fcstOutTSC.fullName = "/".join(newPathName)
fcstOutTSC.times = outTimes
fcstOutTSC.values = outVals
print fcstOutTSC.fullName
print(outVals)
fcstOutTSC.numberValues = len(outVals)
fcstOutTSC.startTime = outTimes[0]
fcstOutTSC.units = fcstTSC.units
fcstOutTSC.type = "INST-VAL"
return fcstOutTSC
def processPathsDatesList(sP):
sT = []
# print '\nsP: ', sP
for p in sP:
s = dssFile.get(p, 1)
sT.append(s.times)
# print '\nsT: ', sT
# timesListHec = []
t = HecTime()
dList = []
for p in sT:
iList = []
for i in p:
t.set(i)
h = t.date(4)
iList.append(deepcopy(h))
dList.append(iList)
# print '\ndList: ', dList
return dList
def createTSrecord(dss_filename, pathname, start_time, values, comp_step,
data_units):
start = HecTime()
tsc = TimeSeriesContainer()
tsc.fullName = pathname
tsc.interval = comp_step
start.set(start_time)
times = []
for value in values:
times.append(start.value())
start.add(tsc.interval)
tsc.values = values
tsc.times = times
tsc.startTime = times[0]
tsc.endTime = times[-1]
tsc.numberValues = len(values)
tsc.units = data_units
tsc.type = "INST-VAL"
dss_file = HecDss.open(dss_filename)
dss_file.put(tsc)
dss_file.done()
def makeTimeSeriesContainer(station, interval, tz, records, decodeInfo):
global timezones
sdf = SimpleDateFormat("ddMMMyyyy, HH:mm")
if dssTimezone:
if not timezones["DSS"]:
timezones["DSS"] = TimeZone.getTimeZone(
tzInfo[dssTimezone]["JAVA"])
sdf.setTimeZone(timezones["DSS"])
else:
sdf.setTimeZone(timezones["USGS"])
dd, decodeInfo = decodeInfo
cal = Calendar.getInstance()
t = HecTime()
tsc = TimeSeriesContainer()
tsc.interval = interval
times = []
values = []
tsc.quality = None
factor = decodeInfo["DSS_FACTOR"]
for j in range(len(records)):
millis, value = records[j]
cal.setTimeInMillis(millis)
t.set(sdf.format(cal.getTime()))
times.append(t.value())
try:
values.append(float(value) * factor)
except:
values.append(Constants.UNDEFINED)
tsc.times = times
tsc.values = values
tsc.startTime = times[0]
tsc.endTime = times[-1]
tsc.numberValues = len(values)
tsc.timeZoneID = sdf.getTimeZone().getID()
tsc.timeZoneRawOffset = sdf.getTimeZone().getRawOffset()
return tsc
def timeWindowMod(runtimeWindow, alternative, computeOptions):
originalRTW = computeOptions.getRunTimeWindow()
dssFile = DSS.open(computeOptions.getDssFilename(), originalRTW.getTimeWindowString())
# pathname for breaches
twmTSM = TimeSeriesMath(alternative.getTimeSeries()) # assumes this is the mapped input to TWM
twmPath = twmTSM.getPath().split("/") # use this for e/f parts
breachPath = "/".join(["", "","BREACHTRACKER-TIMESTEPS REMAINING","TIMESTEPS REMAINING","",twmPath[5], twmPath[6], ""])
# find start and end of breach timeseries
breaches = dssFile.read(breachPath)
dssFile.done()
breachTSC = breaches.getData()
start, end = None, None
rtwStart = runtimeWindow.getStartTime().value()
newStart = HecTime() # keep track of start time that is a valid ResSim timestep
for t,v in zip(breachTSC.times, breachTSC.values):
if v > 0:
if start is None: # first non-zero
start = t
end = t
# update until original start time occurs, make sure this is prev. timestep in ResSim
# avoids interpolated input on start timestep in RAS
if t <= rtwStart:
newStart.set(t)
# no breach
if start is None:
runtimeWindow.setStartTime(newStart)
return runtimeWindow
# compare and adjust if needed
startTime = HecTime()
startTime.set(start)
startTime.subtractDays(RAS_START_BUFFER) # add days to give RAS a little spin up time
if startTime <= runtimeWindow.getStartTime():
runtimeWindow.setStartTime(startTime)
endTime = HecTime()
endTime.set(end)
endTime.addDays(RAS_END_BUFFER) # buffer at end
if endTime >= runtimeWindow.getEndTime():
runtimeWindow.setEndTime(endTime)
alternative.addComputeMessage("New time window set: %s" % runtimeWindow.getTimeWindowString())
return runtimeWindow
def createTemplateTSC(rawDataList): #Derives a TimeSeriesContainer object from the raw ESP data list # where all that needs to be done is update the pathname # and values - timestamps should be uniform across each # ESP trace #intializing HEC java objects tsc =TimeSeriesContainer() #new TSC object hecStartTime= HecTime() hecEndTime = HecTime() #copmuting HEC times and interval (minutes) of timestep times = [] for i in range(len(rawDataList)): times.append(rawDataList[i][0]) hecStartTime.set(times[0]) hecEndTime.set(times[-1]) #The formatting of these times might need to be adjusted at a later point Dates = [] for x in range(len(times)): IndividualDate = times[x] T = HecTime() T.set(IndividualDate) Dates.append(T.value()) DiffBetweenInterval = [] DiffBetweenInterval = [a - Dates[i-1] for i, a in enumerate(Dates)][1:] for x in DiffBetweenInterval: UniqueList_Minutes = [] #Check if exist in list or not if x not in UniqueList_Minutes: UniqueList_Minutes.append(x) interval =UniqueList_Minutes[0] hecTimes = list(range(Dates[0],Dates[-1],int(interval))) hecTimes.append(Dates[-1]) interval_hours = int(interval)/60 tsc.times = hecTimes tsc.values = [Constants.UNDEFINED]*len(times) #add null data number here. tsc.interval = interval_hours tsc.startTime =(int(hecStartTime.julian())*1440)+1080 tsc.endTime =(int( hecEndTime.julian())*1440)+1080 tsc.numberValues = len(times) tsc.units = "CFS" tsc.type = "PER-AVER" tsc.parameter = "FLOW" #Assuming always want this to be flow return tsc
if flow.numberValues == 0:
MessageBox.showError('No Data', 'Error')
else:
csvWriter.writerow(['Location Ids', 'Hanwella'])
csvWriter.writerow(['Time', 'Flow'])
print flow.values[:1], flow.times[:1]
print flow.values[-1], flow.times[-1]
csvList = []
for i in range(0, flow.numberValues):
# print int(flow.times[i])
time = HecTime()
time.set(int(flow.times[i]))
d = [
time.year(),
'%d' % (time.month(), ),
'%d' % (time.day(), )
]
t = [
'%d' % (time.hour(), ),
'%d' % (time.minute(), ),
'%d' % (time.second(), )
]
if (int(t[0]) > 23):
t[0] = '23'
dtStr = '-'.join(str(x) for x in d) + ' ' + ':'.join(
str(x) for x in t)
def makeTimeSeriesContainer(tsData, timeZone, pathname=None):
'''
Construct a TimeSeriesContainer object from a python dictionary that was
created from a single "time-series" returned from the CWMS RADAR web
service
'''
#---------------#
# initial setup #
#---------------#
tsc = None
try:
tz = TimeZone.getTimeZone(timeZone)
sdf8601 = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssXXX")
sdfHecTime = SimpleDateFormat("ddMMMyyyy, HH:mm")
cal = Calendar.getInstance()
for obj in sdf8601, sdfHecTime, cal:
obj.setTimeZone(tz)
ht = HecTime()
times, values, qualities = [], [], []
#------------------#
# process the data #
#------------------#
if tsData.has_key("regular-interval-values"):
#----------------------------------------#
# regular time series (a lot to process) #
#----------------------------------------#
rts = tsData["regular-interval-values"]
intvlStr = rts["interval"]
unit = rts["unit"].split()[0]
if intvlStr.startswith("PT"):
intvlNum, intvlUnit = int(intvlStr[2:-1]), intvlStr[-1]
try:
factor, field = {
"M": (1, Calendar.MINUTE),
"H": (60, Calendar.HOUR_OF_DAY)
}[intvlUnit]
except KeyError:
raise Exception("Unexpected interval: %s" % intvlStr)
else:
intvlNum, intvlUnit = int(intvlStr[1:-1]), intvlStr[-1]
try:
factor, field = {
"Y": (1440 * 365, Calendar.YEAR),
"M": (1440 * 30, Calendar.MONTH),
"D": (1440, Calendar.DATE)
}[intvlUnit]
except KeyError:
raise Exception("Unexpected interval: %s" % intvlStr)
intvl = intvlNum * factor
segmentCount = rts["segment-count"]
cal.setTimeInMillis(
sdf8601.parse(rts["segments"][0]["first-time"]).getTime())
for i in range(segmentCount):
for j in range(rts["segments"][i]["value-count"]):
ht.set(sdfHecTime.format(cal.getTimeInMillis()))
v, q = rts["segments"][i]["values"][j]
times.append(ht.value())
values.append(v)
qualities.append(q)
cal.add(field, intvlNum)
if i < segmentCount - 1:
nextBegin = sdf8601.parse(
rts["segments"][i + 1]["first-time"]).getTime()
time = cal.getTimeInMillis()
while time < nextBegin:
ht.set(sdfHecTime.format(time))
times.append(ht.value())
values.append(Constants.UNDEFINED)
qualities.append(0)
cal.add(field, intvlNum)
time = cal.getTimeInMillis()
elif tsData.has_key("irregular-interval-values"):
#------------------------------#
# irregular time series (easy) #
#------------------------------#
its = tsData["irregular-interval-values"]
unit = its["unit"].split()[0]
intvl = 0
for t, v, q in its["values"]:
ht.set(sdfHecTime.format(sdf8601.parse(t)))
times.append(ht.value())
values.append(v)
qualities.append(q)
else:
raise Exception("Time series has no values")
#--------------------------------------------------#
# code common to regular and irregular time series #
#--------------------------------------------------#
tsc = TimeSeriesContainer()
tsc.times = times
tsc.values = values
tsc.quality = qualities
tsc.numberValues = len(times)
tsc.startTime = times[0]
tsc.endTime = times[-1]
tsc.interval = intvl
tsc.units = unit
tsc.timeZoneID = timeZone
tsc.timeZoneRawOffset = tz.getRawOffset()
name = tsData["name"]
loc, param, paramType, intv, dur, ver = name.split(".")
if pathname:
#---------------------------#
# use pathname if specified #
#---------------------------#
A, B, C, D, E, F = 1, 2, 3, 4, 5, 6
parts = pathname.split("/")
parts[D] = ''
tsc.fullName = "/".join(parts)
tsc.watershed = parts[A]
try:
tsc.location, tsc.subLocation = parts[B].split("-", 1)
except:
tsc.location = parts[B]
try:
tsc.parameter, tsc.subParameter = parts[C].split("-", 1)
except:
tsc.parameter = parts[C]
try:
tsc.version, tsc.subVersion = parts[F].split("-", 1)
except:
tsc.version = parts[F]
else:
#--------------------------------------#
# no pathname, use CWMS time series id #
#--------------------------------------#
try:
tsc.location, tsc.subLocation = loc.split("-", 1)
except:
tsc.location = loc
try:
tsc.parameter, tsc.subParameter = param.split("-", 1)
except:
tsc.parameter = param
try:
tsc.version, tsc.subVersion = ver.split("-", 1)
except:
tsc.version = ver
tsc.type = {
"Total": "PER-CUM",
"Max": "PER-MAX",
"Min": "PER-MIN",
"Const": "INST-VAL",
"Ave": "PER-AVER",
"Inst": ("INST-VAL", "INST-CUM")[param.startswith("Precip")]
}[paramType]
except:
output(traceback.format_exc())
return tsc
loc = "OAKVILLE"
param = "STAGE"
ver = "OBS"
startTime = "12Oct2003 0100"
values = [12.36, 12.37, 12.42, 12.55, 12.51, 12.47, 12.43, 12.39]
hecTime = HecTime()
tsc = TimeSeriesContainer()
tsc.watershed = watershed
tsc.location = loc
tsc.parameter = param
tsc.version = ver
tsc.fullName = "/%s/%s/%s//1HOUR/%s/" % (watershed, loc, param, ver)
tsc.interval = 60
hecTime.set(startTime)
times=[]
for value in values:
times.append(hecTime.value())
hecTime.add(tsc.interval)
tsc.values = values
tsc.times = times
tsc.startTime = times[0]
tsc.endTime = times[-1]
tsc.numberValues = len(values)
tsc.units = "FEET"
tsc.type = "INST-VAL"
dssFile = HecDss.open("myFile.dss")
flow = dss.get(path,True)
if (TS and hasattr(flow,'times')):
pathArray=path.split('/')
pathArray[4]=''
parsepath='/'.join(pathArray)
if (parsepath in visited):
continue
else:
visited[parsepath]=True
vs=[]
try:
for i in (range(len(flow.times))):
t=HecTime()
t.set(flow.times[i])
date=str(t.year())+'-'+str(t.month())+'-'+str(t.day())
val="%.3f}" % flow.values[i];
vs.append('""('+str(date)+','+val+')""')
except :
vs=[]
v='"{'+','.join(vs)+'}"'
st=HecTime()
st.set(flow.startTime)
sd=str(st.year())+'-'+str(st.month())+'-'+str(st.day())
et=HecTime()
et.set(flow.endTime)
ed=str(et.year())+'-'+str(et.month())+'-'+str(et.day())
parms=['"'+path+'"',
sd,
print '\nsP: ', sP
sT = []
for p in sP:
s = dssFile.get(p, 1)
sT.append(s.times)
# print 'sT:', sT
timesListHec = []
t = HecTime()
dList = []
for p in sT:
# print '\np: ', p
iList = []
for i in p:
# print '\ni: ', i
t.set(i)
# h = t.dateAndTime(4)
h = t.date(4)
iList.append(deepcopy(h))
dList.append(iList)
print '\ndList: ', dList
print '\n#----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#'
print '#End Process Dates to tList'
print '#----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#'
#for outerlist in zip(sweData, tData, pData):
# for innerlist in outerlist:
# print 'length of each list of Zipped Values: ', len(innerlist)
#
#for l in sweData:
MessageBox.showError(
"DSS was unable to open the RAS DSS file. \n The filename provided is: %s \n Please check to see that your RAS project is exporting data to this file!"
% (dss_filename), "DSS unable to open file!")
dss_file = HecDss.open(dss_filename, start_time, end_time)
try:
math = dss_file.read(pathname)
dss_file.done()
tsc = math.getData()
values = tsc.values
times = tsc.times
time_str = HecTime()
time_list = []
for t in times:
time_str.set(t)
time_list.append(HecTime.dateAndTime(time_str))
text_file = open(output_filename, "w")
text_file.write("Data: \n %s \n" % values)
text_file.write("Time String: \n %s \n" % time_list)
text_file.write("Time Minutes: \n %s" % times)
text_file.close()
except:
text_file = open(output_filename, "w")
text_file.write("NO DATA")
text_file.close()
MessageBox.showError(
"DSS was unable to find the path associated with the file. \n The DSS File is: %s \n The Path is: %s \n Please check to see that your DSS file contains the specified path!"
% (dss_filename, pathname), "DSS unable to find computed path!")