def run_ddrange(stn, ddtype, accstr, accend):
try:
base = newaCommon.Base()
cabbage = newaDisease.Cabbage()
smry_dict = {'ddtype': ddtype.replace("dd", "")}
now = DateTime.now()
if not accend:
accend = now
end_date_dt = accend
if not accstr:
accstr = DateTime.DateTime(end_date_dt.year, 1, 1, 0)
start_date_dt = accstr
if start_date_dt > end_date_dt:
return newaCommon_io.errmsg('Start date must be before end data.')
if end_date_dt.year != now.year:
smry_dict['this_year'] = False
end_date_dt = end_date_dt + DateTime.RelativeDate(days=+6)
else:
smry_dict['this_year'] = True
hourly_data, daily_data, download_time, station_name, avail_vars = base.get_hddata2(
stn, start_date_dt, end_date_dt)
smry_dict['last_time'] = download_time
# add forecast data
if smry_dict['this_year']:
start_fcst_dt = DateTime.DateTime(
*download_time) + DateTime.RelativeDate(hours=+1)
end_fcst_dt = end_date_dt + DateTime.RelativeDate(days=+6)
hourly_data = newaDisease.add_hrly_fcst(stn, hourly_data,
start_fcst_dt, end_fcst_dt)
daily_data = newaDisease.hrly_to_dly(hourly_data)
else:
start_fcst_dt = end_date_dt + DateTime.RelativeDate(hours=+1)
end_fcst_dt = end_date_dt
end_date_dt = end_date_dt + DateTime.RelativeDate(days=-6)
if len(daily_data) > 0:
degday_dict = base.degday_calcs(daily_data, start_date_dt,
end_fcst_dt, ddtype, "accum")
if len(degday_dict) > 0:
# get dates for gdd table
smry_dict = cabbage.setup_dates(smry_dict, end_date_dt)
# get dd for days of interest (including forecast)
smry_dict = cabbage.add_ddays(smry_dict, degday_dict,
start_date_dt, end_date_dt)
return newaLister_io.ddrange_html(station_name, smry_dict,
degday_dict)
else:
return self.nodata(stn, station_name, start_date_dt,
end_date_dt)
else:
return self.nodata(stn, station_name, start_date_dt, end_date_dt)
except:
print_exception()
return
def apple_thin_json(data_dict, biofix_dt, bloom_dt, percentflowerspurs):
results_list = []
notes_list = []
try:
results_list = []
notes_list = []
tkeys = data_dict.keys()
tkeys.sort()
if bloom_dt:
recommendEnd = bloom_dt + DateTime.RelativeDate(days=+35)
else:
recommendEnd = None
if len(tkeys) >= 4:
list7day = [miss, miss, miss, data_dict[0]['thinIndex'], data_dict[1]['thinIndex'], \
data_dict[2]['thinIndex'], data_dict[3]['thinIndex']]
else:
list7day = []
for key in tkeys:
t_dt = biofix_dt + DateTime.RelativeDate(days=+key, hour=0, minute=0, second=0.0)
fdate = "%d-%02d-%02d" % (t_dt.year,t_dt.month,t_dt.day)
if data_dict[key]['maxt'] == miss or data_dict[key]['mint'] == miss or data_dict[key]['srad'] == miss:
data_dict[key]['thinIndex'] = miss
if key+4 < len(tkeys) and data_dict[key+4]['maxt'] != miss and data_dict[key+4]['mint'] != miss and data_dict[key+4]['srad'] != miss:
list7day.append(data_dict[key+4]['thinIndex'])
else:
list7day.append(miss)
list7day.pop(0)
if len(list7day) == 7 and not miss in list7day:
#avg7day_STRAIGHT = round((sum(list7day)/7.0), 2)
# changed straight average to 7-day weighted average - kle 2021-3-18
wtsum = 0
wtsum += list7day[0] * 0.3
wtsum += list7day[1] * 0.5
wtsum += list7day[2]
wtsum += list7day[3]
wtsum += list7day[4]
wtsum += list7day[5] * 0.8
wtsum += list7day[6] * 0.6
avg7day = round((wtsum / 5.2), 2)
else:
avg7day = "-"
if bloom_dt and t_dt >= bloom_dt and t_dt <= recommendEnd:
recommend = get_recommend(avg7day, percentflowerspurs, mround(data_dict[key]['dd4cAccum'],0))
else:
recommend = {"efficacy": "NA", "riskColor": 0, "recommend": "-"}
# results_list.append([fdate, ctof(data_dict[key]['maxt']), ctof(data_dict[key]['mint']),\
# mround(data_dict[key]['srad'],1), mround(data_dict[key]['thinIndex'],2),avg7day, mround(data_dict[key]['dd4cAccum'],1), recommend])
day_results = {'date': fdate, 'maxt':ctof(data_dict[key]['maxt']), 'mint': ctof(data_dict[key]['mint']),\
'srad': mround(data_dict[key]['srad'],1), 'thinIndex': mround(data_dict[key]['thinIndex'],2), \
'avg7day': avg7day, 'dd4cAccum': mround(data_dict[key]['dd4cAccum'],1)}
day_results.update(recommend)
results_list.append(day_results)
if bloom_dt and (bloom_dt - biofix_dt).days < 21:
notes_list.append('Difference between Green tip and Bloom is less than 21 days. Results may be unreliable.')
except:
print_exception()
return {"data":results_list, "notes":notes_list}
def run_apple_thin (stn,accend,greentip,bloom,percentflowerspurs,output):
try:
id_parts = stn.split(" ")
if len(id_parts) == 1:
if stn[0:3] == '42.' or stn[0:3] == '43.':
station_type = 'ucc'
elif stn[0:1] >= '1' and stn[0:1] <= '9' and stn[1:2] >= '0' and stn[1:2] <= '9':
station_type = 'njwx'
elif len(stn) == 4 and stn[0:1].upper() == 'K':
station_type = 'icao'
elif len(stn) == 4:
station_type = 'oardc'
elif stn[0:3] == 'cu_' or stn[0:3] == 'um_' or stn[0:3] == 'un_' or stn[0:3] == 'uc_':
station_type = 'cu_log'
elif stn[0:3] == "ew_":
stn = stn[3:]
station_type = 'miwx'
elif stn[0:5] == "nysm_":
stn = stn[5:]
station_type = 'nysm'
elif len(stn) == 7 and stn[2:3] == "_":
station_type = 'nwon'
elif len(stn) == 3 or len(stn) == 6:
station_type = 'newa'
else:
raise StationProblem('Cannot determine station type for %s'%stn)
else:
stn = id_parts[0]
station_type = id_parts[1]
try:
biofix_dt = greentip + DateTime.RelativeDate(hour=0, minute=0, second=0.0)
except TypeError:
return newaTools_io.apple_thin_results(None)
try:
bloom_dt = bloom + DateTime.RelativeDate(hour=0, minute=0, second=0.0)
except TypeError:
bloom_dt = None
#date range
accend = accend + DateTime.RelativeDate(hour=0,minute=0,second=0.0)
## start_date_dt = accend + DateTime.RelativeDate(days=-7) + DateTime.RelativeDate(hour=0,minute=0,second=0.0)
start_date_dt = biofix_dt
end_date_dt = accend + DateTime.RelativeDate(days=+6) + DateTime.RelativeDate(hour=23,minute=0,second=0.0)
# get model results
data_dict = apple_thinning_model (stn, start_date_dt, end_date_dt, bloom_dt, station_type)
json_dict = apple_thin_json(data_dict, biofix_dt, bloom_dt,percentflowerspurs)
except:
print_exception()
if output == 'json':
return json.dumps(json_dict)
else:
thin_dict = {'selectedDate': accend, 'greentipDate': biofix_dt, 'bloomDate': bloom_dt}
json_dict.update(thin_dict)
return newaTools_io.apple_thin_results(json_dict)
def run_apple_et (stn,accend,greentip,output):
et_dict = {}
try:
#date range
start_date_dt = accend + DateTime.RelativeDate(days=-7) + DateTime.RelativeDate(hour=0,minute=0,second=0.0)
end_date_dt = accend + DateTime.RelativeDate(days=+6) + DateTime.RelativeDate(hour=23,minute=0,second=0.0)
id_parts = stn.split(" ")
if len(id_parts) == 1:
if stn[0:3] == '42.' or stn[0:3] == '43.':
station_type = 'ucc'
elif stn[0:1] >= '1' and stn[0:1] <= '9' and stn[1:2] >= '0' and stn[1:2] <= '9':
station_type = 'njwx'
elif len(stn) == 4 and stn[0:1].upper() == 'K':
station_type = 'icao'
elif len(stn) == 4:
station_type = 'oardc'
elif stn[0:3] == 'cu_' or stn[0:3] == 'um_':
station_type = 'cu_log'
elif stn[0:3] == "ew_":
stn = stn[3:]
station_type = 'miwx'
elif stn[0:5] == "nysm_":
stn = stn[5:]
station_type = 'nysm'
elif len(stn) == 7 and stn[2:3] == "_":
station_type = 'nwon'
elif len(stn) == 3 or len(stn) == 6:
station_type = 'newa'
else:
raise StationProblem('Cannot determine station type for %s'%stn)
else:
stn = id_parts[0]
station_type = id_parts[1]
try:
biofix_dt = greentip + DateTime.RelativeDate(hour=0, minute=0, second=0.0)
except TypeError:
return newaTools_io.apple_et_results(None)
# get daily modeled et, solar rad and precipitation
et_dict['data'] = apple_hourly (stn, start_date_dt, end_date_dt, biofix_dt, station_type)
except:
print_exception()
if output == 'json':
import json
results_list = []
etkeys = et_dict['data'].keys()
etkeys.sort()
for key in etkeys:
fdate = "%d-%02d-%02d" % (key[0],key[1],key[2])
results_list.append([fdate,round(et_dict['data'][key]['et'],2),round(et_dict['data'][key]['prcp'],2)])
json_dict = json.dumps({"data":results_list})
return json_dict
else:
return newaTools_io.apple_et_results(et_dict)
def get_precip_forecast(stn, start_date_dt, end_date_dt):
hourly_fcst = []
miss = -999
try:
stn = stn.upper()
pdict = hashopen('/ndfd/hourly_forecasts.db', 'r')
if pdict.has_key(stn):
stndict = loads(pdict[stn])
pdict.close()
firstday_hour = start_date_dt.hour
lastday_hour = end_date_dt.hour
start_date_dt = start_date_dt + DateTime.RelativeDate(hour=0)
end_date_dt = end_date_dt + DateTime.RelativeDate(hour=0)
theDate_dt = start_date_dt
while theDate_dt <= end_date_dt:
theDate = (theDate_dt.year, theDate_dt.month, theDate_dt.day)
if stndict['qpf'].has_key(theDate):
qpf = stndict['qpf'][theDate]
else:
qpf = [miss] * 24
if stndict['pop12'].has_key(theDate):
pop12 = stndict['pop12'][theDate]
else:
pop12 = [miss] * 24
if theDate_dt == start_date_dt:
shour = firstday_hour
else:
shour = 0
if theDate_dt == end_date_dt:
ehour = lastday_hour
else:
ehour = 23
for hr in range(shour, ehour + 1):
theTime = (theDate_dt.year, theDate_dt.month,
theDate_dt.day, hr)
hourly_fcst.append((theTime, qpf[hr], pop12[hr]))
# distribute precipitation over last 6 hours
if qpf[hr] != miss:
x = len(hourly_fcst) - 1
for i in range(x, x - 6, -1):
if i >= 0:
hourly_fcst[i] = hourly_fcst[i][0:1] + (
qpf[hr] / 6., ) + hourly_fcst[i][2:]
theDate_dt = theDate_dt + DateTime.RelativeDate(days=+1)
except:
print_exception()
return hourly_fcst
#stn = 'cli'
#start_date_dt = DateTime.DateTime(2009,4,16,8)
#end_date_dt = DateTime.DateTime(2009,4,22,23)
#forecast_dict = get_precip_forecast(stn,start_date_dt,end_date_dt)
#for item in forecast_dict:
# print item
def run_apple_thin_specs (stn,accend,output):
et_dict = {}
#date range
start_date_dt = accend + DateTime.RelativeDate(days=-7) + DateTime.RelativeDate(hour=0,minute=0,second=0.0)
end_date_dt = accend + DateTime.RelativeDate(days=+6) + DateTime.RelativeDate(hour=23,minute=0,second=0.0)
fcst_stn = copy.deepcopy(stn)
id_parts = stn.split(" ")
if len(id_parts) == 1:
if stn[0:3] == '42.' or stn[0:3] == '43.':
station_type = 'ucc'
elif stn[0:1] >= '1' and stn[0:1] <= '9' and stn[1:2] >= '0' and stn[1:2] <= '9':
station_type = 'njwx'
elif len(stn) == 4 and stn[0:1].upper() == 'K':
station_type = 'icao'
elif len(stn) == 4:
station_type = 'oardc'
elif stn[0:3] == 'cu_' or stn[0:3] == 'um_' or stn[0:3] == 'un_' or stn[0:3] == 'uc_':
station_type = 'cu_log'
elif stn[0:3] == "ew_":
stn = stn[3:]
station_type = 'miwx'
elif stn[0:5] == "nysm_":
stn = stn[5:]
station_type = 'nysm'
elif len(stn) == 7 and stn[2:3] == "_":
station_type = 'nwon'
elif len(stn) == 3 or len(stn) == 6:
station_type = 'newa'
else:
raise StationProblem('Cannot determine station type for %s'%stn)
else:
stn = id_parts[0]
station_type = id_parts[1]
#need to get greentip and bloom date in DateTime format
biofix_dd = phen_events_dict['macph_greentip_43']['dd'][2] #green tip degree day accumulation
bloom_dd = phen_events_dict['macph_bloom_43']['dd'][2] #bloom degree day accumulation
hourly_data = {}
jan1_dt = DateTime.DateTime(end_date_dt.year,1,1,0,0,0)
fcst_data = get_fcst_data (fcst_stn, 'temp', jan1_dt, end_date_dt)
hourly_data = get_hourly_data (stn, 'temp', jan1_dt, end_date_dt, hourly_data, fcst_data, station_type)
biofix_dt, ddmiss = BaseTools().find_biofix (hourly_data, jan1_dt, end_date_dt, 'dd43be', biofix_dd)
bloom_dt, bloom_ddmiss = BaseTools().find_biofix (hourly_data, jan1_dt, end_date_dt, 'dd43be', bloom_dd)
if biofix_dt and ddmiss <= 7:
et_dict['greentip'] = '%d/%d/%d' % (biofix_dt.month,biofix_dt.day,biofix_dt.year)
if bloom_dt and bloom_ddmiss <= 7:
et_dict['bloom'] = '%d/%d/%d' % (bloom_dt.month,bloom_dt.day,bloom_dt.year)
ucanid,station_name = get_metadata (stn, station_type)
et_dict['station_name'] = station_name
return newaTools_io.apple_thin_specs(et_dict)
def tp_for_grf(stn, daily_data, smry_dict, start_date_dt, end_date_dt):
obs_dict = {}
forecast_data = None
try:
mint = []
maxt = []
prcpl = []
obs_days = []
first = 1
for dly_dt, tave_hr, tmax, tmin, prcp, lwet, rhum, wspd, srad, st4a, st4x, st4n, dflags in daily_data:
this_day_dt = DateTime.DateTime(dly_dt[0], dly_dt[1], dly_dt[2])
if this_day_dt < start_date_dt: continue
if tmax != miss and tmin != miss:
if first:
first = 0
mint.append(int(round(tmin, 0)))
maxt.append(int(round(tmax, 0)))
prcpl.append(prcp)
obs_days.append("%d-%d-%d" % (dly_dt[0], dly_dt[1], dly_dt[2]))
obs_dict['maxt'] = maxt
obs_dict['mint'] = mint
obs_dict['prcp'] = prcpl
obs_dict['obs_days'] = obs_days
obs_dict['fmaxt'] = []
obs_dict['fmint'] = []
obs_dict['fprcp'] = []
obs_dict['frobs_days'] = []
# get daily forecast data
start_fcst_dt = DateTime.DateTime(
*daily_data[-1][0]) + DateTime.RelativeDate(days=+1)
end_fcst_dt = end_date_dt + DateTime.RelativeDate(days=+6)
if end_fcst_dt >= start_fcst_dt:
fmint = []
fmaxt = []
fprcp = []
fobs_days = []
forecast_data = get_daily_forecast(stn, start_fcst_dt, end_fcst_dt)
for dly_dt, tave_hr, tmax, tmin, prcp, lwet, rhum, wspd, srad, st4a, st4x, st4n, dflags in forecast_data:
if tmax != miss and tmin != miss:
if first:
first = 0
fmint.append(int(round(tmin, 0)))
fmaxt.append(int(round(tmax, 0)))
fprcp.append(prcp)
fobs_days.append("%d-%d-%d" %
(dly_dt[0], dly_dt[1], dly_dt[2]))
obs_dict['fmaxt'] = fmaxt
obs_dict['fmint'] = fmint
obs_dict['fprcp'] = fprcp
obs_dict['frobs_days'] = fobs_days
except:
print_exception()
return obs_dict, smry_dict, forecast_data
def deghr_for_grf(hourly_data, start_date, end_date):
deghr_dict = {}
try:
dly_sum = 0.
dly_msg = 0.
d4_dh = []
dly_d4dh_list = []
date_list = []
start_date = start_date + DateTime.RelativeDate(
days=+1) #start deghr accumulation day after biofix
start_date = start_date + DateTime.RelativeDate(
hour=0, minute=0, second=0)
end_date = end_date + DateTime.RelativeDate(
hour=23, minute=59, second=59)
for theTime, temp, prcp, lwet, rhum, wspd, wdir, srad, st4i, eflags in hourly_data:
temp_eflag, prcp_eflag, lwet_eflag, rhum_eflag, wspd_eflag, wdir_eflag, srad_eflag, st4i_eflag = eflags
this_date = DateTime.DateTime(*theTime)
if this_date >= start_date and this_date <= end_date:
if temp != miss:
ddval = newaModel.Apple().get_dhr(temp)
dly_sum = dly_sum + ddval
else:
dly_msg = dly_msg + 1
# save daily values
if theTime[3] == 23:
if dly_msg >= 2: dly_sum = miss
if len(d4_dh) == 4:
del d4_dh[0] #keep total for last 4 days
d4_dh.append(dly_sum)
if d4_dh.count(miss) == 0 and len(d4_dh) > 0:
fdate = "%d-%d-%d" % (theTime[0], theTime[1],
theTime[2])
date_list.append(fdate)
dly_d4dh_list.append(int(sum(d4_dh)))
dly_sum = 0.
dly_msg = 0
# get last partial day
if theTime[3] != 23:
if dly_msg >= 2: dly_sum = miss
if len(d4_dh) == 4: del d4_dh[0] #keep total for last 4 days
d4_dh.append(dly_sum)
if d4_dh.count(miss) == 0 and len(d4_dh) > 0:
fdate = "%d-%d-%d" % (theTime[0], theTime[1], theTime[2])
date_list.append(fdate)
dly_d4dh_list.append(int(sum(d4_dh)))
deghr_dict['dates'] = date_list
deghr_dict['d4dh'] = dly_d4dh_list
except:
print 'Error calculating degree hours'
print_exception()
return deghr_dict
def get_mildew_missing(self):
last_date = self.dates[-1]
last_time = apply(DateTime.Date, last_date)
sTime = last_time + DateTime.RelativeDate(hours=+1)
eTime = DateTime.DateTime(sTime.year + 1, 1, 1, 0)
missing_hours = []
missing_days = []
while sTime < eTime:
localTime = getLocalFromEST_time(sTime)
missing_days.append(localTime.day_of_year)
missing_hours.append(localTime.hour)
sTime = sTime + DateTime.RelativeDate(hours=+1)
return (missing_days, missing_hours)
def ascospore_for_grf(dd_data, daily_data):
ascospore_dict = {}
try:
daily_prec = []
# need precip for six days preceding greentip (first day in dd_data)
first_dt = DateTime.DateTime(dd_data[0][0][0], dd_data[0][0][1],
dd_data[0][0][2])
minus6_dt = first_dt + DateTime.RelativeDate(days=-6)
minus6_list = [minus6_dt.year, minus6_dt.month, minus6_dt.day]
for i in range(len(daily_data)):
dly_dt, tave_hr, tmax, tmin, prcp, lwet, rhum, wspd, srad, st4a, st4x, st4n, dflags = daily_data[
i]
if dly_dt == minus6_list:
daily_prec.append(daily_data[i][4])
daily_prec.append(daily_data[i + 1][4])
daily_prec.append(daily_data[i + 2][4])
daily_prec.append(daily_data[i + 3][4])
daily_prec.append(daily_data[i + 4][4])
daily_prec.append(daily_data[i + 5][4])
accum_dd = 0.
date_list = []
matur_list = []
error_list = []
for dly_dt, tmax, tmin, ddval, prec in dd_data:
fdate = "%d-%d-%d" % (dly_dt[0], dly_dt[1], dly_dt[2])
if prec != miss:
daily_prec.append(prec)
else:
daily_prec.append(0.)
if len(daily_prec) > 7:
del daily_prec[0]
prec7dy = sum(daily_prec)
else:
prec7dy = miss
if prec7dy > 0.00 or prec7dy == miss:
if ddval != miss: accum_dd = accum_dd + ddval
else:
pass #don't accumulate anything during dry period
if ddval != miss:
comp = math.exp(
(math.pi / math.sqrt(3)) * ((-2.49 + (0.01 * accum_dd))))
maturity = 100. * (comp) / (1. + comp)
comp2 = math.exp(
(math.pi / math.sqrt(3)) * ((-1.676 + (0.01 * accum_dd))))
error = 100. * (comp2 / (1. + comp2)) - maturity
else:
maturity = miss
error = miss
if maturity != miss:
date_list.append(fdate)
matur_list.append(maturity)
error_list.append(error)
ascospore_dict['dates'] = date_list
ascospore_dict['maturity'] = matur_list
ascospore_dict['error'] = error_list
except:
print_exception()
return ascospore_dict
def get_dates(self, obsTime, eTime):
sTime = DateTime.DateTime(obsTime.year, obsTime.month, obsTime.day,
obsTime.hour)
dateList = []
while sTime < eTime:
this_date = [sTime.year, sTime.month, sTime.day, sTime.hour]
dateList.append(this_date)
sTime = sTime + DateTime.RelativeDate(hours=+1)
return dateList
def apple_thin_json(thin_dict, biofix_dt, bloom_dt):
results_list = []
notes_list = []
try:
import json
results_list = []
notes_list = []
tkeys = thin_dict['data'].keys()
tkeys.sort()
recommendEnd = bloom_dt + DateTime.RelativeDate(days=+35)
if len(tkeys) >= 3:
list4day = [miss, thin_dict['data'][0]['thinIndex'], thin_dict['data'][1]['thinIndex'], thin_dict['data'][2]['thinIndex']]
else:
list4day = []
for key in tkeys:
t_dt = thin_dict['greentipDate'] + DateTime.RelativeDate(days=+key, hour=0, minute=0, second=0.0)
fdate = "%d-%02d-%02d" % (t_dt.year,t_dt.month,t_dt.day)
if thin_dict['data'][key]['maxt'] == miss or thin_dict['data'][key]['mint'] == miss or thin_dict['data'][key]['srad'] == miss:
thin_dict['data'][key]['dlyCarbonBal'] = miss
thin_dict['data'][key]['totalDemand'] = miss
thin_dict['data'][key]['thinIndex'] = miss
if key+3 < len(tkeys) and thin_dict['data'][key+3]['maxt'] != miss and thin_dict['data'][key+3]['mint'] != miss and thin_dict['data'][key+3]['srad'] != miss:
list4day.append(thin_dict['data'][key+3]['thinIndex'])
else:
list4day.append(miss)
list4day.pop(0)
if len(list4day) == 4 and not miss in list4day:
avg4day = round((sum(list4day)/4.0), 2)
else:
avg4day = "-"
if t_dt >= bloom_dt and t_dt <= recommendEnd:
recommend = get_recommend(avg4day)
else:
recommend = "-"
results_list.append([fdate, ctof(thin_dict['data'][key]['maxt']), ctof(thin_dict['data'][key]['mint']),\
mround(thin_dict['data'][key]['srad'],1), mround(thin_dict['data'][key]['dlyCarbonBal'],2),\
mround(thin_dict['data'][key]['totalDemand'],2), mround(thin_dict['data'][key]['thinIndex'],2),\
avg4day, recommend])
if (bloom_dt - biofix_dt).days < 21:
notes_list.append('Difference between Green tip and Bloom is less than 21 days. Results may be unreliable.')
except:
print_exception()
json_dict = json.dumps({"data":results_list, "notes":notes_list})
return json_dict
def get_relative_date(years=None, months=None, days=None):
"""
Calculates relative past date from current time based on input params.
:param years: Number of years from current time
:type: str
:param months: Number of months from current time
:type: str
:param days: Number of days from current time
:type: str
:return: mx.DateTime.DateTime object
"""
exp_date = DateTime.now()
if years is not None:
exp_date = exp_date - DateTime.RelativeDate(years=int(years))
if months is not None:
exp_date = exp_date - DateTime.RelativeDate(months=int(months))
if days is not None:
exp_date = exp_date - DateTime.RelativeDate(days=int(days))
return exp_date
def loop_through_time(self):
obsTime = DateTime.DateTime(self.sTime.year, self.sTime.month,
self.sTime.day, self.sTime.hour)
nexTime = obsTime + DateTime.RelativeDate(months=+1)
while obsTime < self.eTime:
if nexTime > self.eTime:
end = (self.eTime.year, self.eTime.month, self.eTime.day,
self.eTime.hour)
else:
end = (nexTime.year, nexTime.month, nexTime.day, nexTime.hour)
start = (obsTime.year, obsTime.month, obsTime.day, obsTime.hour)
try:
self.get_temperature(start, end)
self.get_precipitation(start, end)
self.get_rh(start, end)
self.get_lwet(start, end)
except weatherError:
break
except:
print_exception()
break
obsTime = DateTime.DateTime(nexTime.year, nexTime.month,
nexTime.day, nexTime.hour)
nexTime = obsTime + DateTime.RelativeDate(months=+1)
self.stn.release_tmp()
if self.tmpVar:
self.tmpVar.release_tmp()
self.stn.release_rh()
if self.rhVar:
self.rhVar.release_rh()
self.stn.release_prcp()
if self.prcpVar:
self.prcpVar.release_prcp()
self.stn.release_lwet()
if self.lwetVar:
self.lwetVar.release_lwet()
def getHourlySolar(stn, start_date, end_date, miss, stpr0, wthr0, dwpt0, visi0,
ccnd0, chgt0, ceil0, tsky0):
import string, Data
from mx import DateTime
from print_exception import print_exception
from solar_main_routine import SOLAR_MAIN
values = []
vdates = []
try:
srdates, srvalues = SOLAR_MAIN(stn, start_date, end_date, stpr0, wthr0,
dwpt0, visi0, ccnd0, chgt0, ceil0,
tsky0)
start_date_dt = DateTime.DateTime(*start_date)
end_date_dt = DateTime.DateTime(*end_date)
sr_start_dt = DateTime.DateTime(*srdates[0])
sr_end_dt = DateTime.DateTime(*srdates[-1])
# pad beginning, if necessary
theDate = start_date_dt
while theDate < sr_start_dt:
vdates.append(theDate.tuple()[:4])
values.append(miss)
theDate = theDate + DateTime.RelativeDate(hours=+1)
# only retain values in requested date range
for vdy in range(len(srdates)):
srdate_dt = DateTime.DateTime(*srdates[vdy])
if srdate_dt >= start_date_dt and srdate_dt < end_date_dt:
vdates.append(srdates[vdy])
# convert from string to value
values.append(string.atof(srvalues[vdy]))
# pad end, if necessary
theDate = sr_end_dt + DateTime.RelativeDate(hours=+1)
while theDate < end_date_dt:
vdates.append(theDate.tuple()[:4])
values.append(miss)
theDate = theDate + DateTime.RelativeDate(hours=+1)
except:
print_exception()
return (values, vdates)
def update_all_days(self) : eTime = apply(DateTime.Date,self.eDate) # # PLEASE NOTE: # For the current program to work, we must start on Jan. 1 # This has impact on figuring out indexes among other things. # sTime = DateTime.DateTime(self.eDate[0],1,1) while sTime <= eTime : this_date = "%02d/%02d"%(sTime.month,sTime.day) self.all_days[sTime.day_of_year] = this_date sTime = sTime + DateTime.RelativeDate(days=+1)
def getDates():
dates_dt = []
for i in range(1, len(sys.argv)):
cols = sys.argv[i].split(",")
if len(cols) == 3:
dates_dt.append(
DateTime.DateTime(int(cols[0]), int(cols[1]), int(cols[2])))
if len(dates_dt) == 2:
# Two arguments are start and end date
sdate = dates_dt[0]
edate = dates_dt[1]
elif len(dates_dt) == 1:
# One argument is end date - do week ending that date
edate = dates_dt[0]
sdate = edate + DateTime.RelativeDate(days=-6)
elif len(dates_dt) == 0:
# No arguments default to week ending yesterday
edate = DateTime.now() + DateTime.RelativeDate(days=-1)
sdate = edate + DateTime.RelativeDate(days=-6)
else:
sys.exit()
return sdate, edate
def get_daily_forecast (stn,start_date_dt,end_date_dt):
daily_fcst = []
miss = -999
try:
stn = stn.upper()
##NEW: next line
forecast_dict = hashopen('/ndfd/daily_forecasts.db','r')
if forecast_dict.has_key(stn):
# get all daily precip for period
hourly_fcst = get_precip_forecast(stn,start_date_dt,end_date_dt)
dly_ppt = {}
ppt_cnt = 0
ppt_sum = 0.0
for dt,qpf,pop in hourly_fcst:
if qpf != miss:
ppt_sum = ppt_sum + qpf
ppt_cnt = ppt_cnt + 1
if dt[3] == 23:
if ppt_cnt > 0: dly_ppt[dt[0:3]] = ppt_sum
ppt_cnt = 0
ppt_sum = 0.0
# get temps and combine with precip, if available
stndict = loads(forecast_dict[stn])
theDate_dt = start_date_dt
while theDate_dt <= end_date_dt:
int_date = (theDate_dt.year,theDate_dt.month,theDate_dt.day)
if stndict.has_key(int_date):
tmax,tmin = stndict[int_date]
tave = (tmax+tmin)/2.
eflags = ('', '', '', 'M', 'M', 'M', 'M', 'M')
else:
tmax,tmin,tave = miss,miss,miss
eflags = ('M', 'M', 'M', 'M', 'M', 'M', 'M', 'M')
if dly_ppt.has_key(int_date):
rain = dly_ppt[int_date]
eflags = (eflags[0],eflags[1],eflags[2],"",'M', 'M', 'M', 'M')
else:
rain = miss
daily_fcst.append(([int_date[0],int_date[1],int_date[2]],tave,tmax,tmin,rain,miss,miss,miss,miss,miss,miss,miss,eflags))
theDate_dt = theDate_dt + DateTime.RelativeDate(days = +1)
forecast_dict.close()
except:
print_exception()
return daily_fcst
#stn = 'cu_gfr'
#start_date_dt = DateTime.DateTime(2009,5,1)
#end_date_dt = DateTime.DateTime(2009,5,18)
#forecast_dict = get_daily_forecast(stn,start_date_dt,end_date_dt)
#for item in forecast_dict:
# print item
def find_biofix (self, hourly_data, jan1_dt, end_date_dt, smry_type, biofix_dd): biofix_date = None ddmiss = None try: ddaccum = 0. ddmiss = 0 dly_max = -999 dly_min = 999 dly_miss = 0 ks = hourly_data.keys() ks.sort() for key_date in ks: theDate = DateTime.DateTime(*key_date) hourly_temp = hourly_data[key_date]['temp'][0] if hourly_temp != miss: if hourly_temp > dly_max: dly_max = copy.deepcopy(hourly_temp) if hourly_temp < dly_min: dly_min = copy.deepcopy(hourly_temp) else: dly_miss = dly_miss + 1 # end of day update if theDate.hour == 23: if dly_miss == 0: dly_dd = BaseTools().calc_degday(dly_max, dly_min, smry_type) else: dly_dd = miss # check to see if biofix gdd accum has been reached if dly_dd != miss: ddaccum = ddaccum + dly_dd else: ddmiss = ddmiss + 1 if round(ddaccum,0) >= biofix_dd: biofix_date = theDate + DateTime.RelativeDate(hours=0) break dly_max = -999 dly_min = 999 dly_miss = 0 except: print_exception() return biofix_date, ddmiss
def tp_for_grf2(daily_data, start_date_dt, start_fcst_dt, useqpf=True):
obs_dict = {}
forecast_data = None
start_fcst_dt = start_fcst_dt + DateTime.RelativeDate(
hour=0, minute=0, second=0)
try:
mint = []
maxt = []
prcpl = []
obs_days = []
fmint = []
fmaxt = []
fprcp = []
fobs_days = []
for dly_dt, tave_hr, tmax, tmin, prcp, lwet, rhum, wspd, srad, qpf, st4x, st4n, dflags in daily_data:
this_day_dt = DateTime.DateTime(dly_dt[0], dly_dt[1], dly_dt[2])
if this_day_dt < start_date_dt: continue
if not useqpf: qpf = prcp
if tmax != miss and tmin != miss:
if this_day_dt < start_fcst_dt:
mint.append(int(round(tmin, 0)))
maxt.append(int(round(tmax, 0)))
prcpl.append(qpf)
obs_days.append("%d-%d-%d" %
(dly_dt[0], dly_dt[1], dly_dt[2]))
else:
fmint.append(int(round(tmin, 0)))
fmaxt.append(int(round(tmax, 0)))
fprcp.append(qpf)
fobs_days.append("%d-%d-%d" %
(dly_dt[0], dly_dt[1], dly_dt[2]))
obs_dict['maxt'] = maxt
obs_dict['mint'] = mint
obs_dict['prcp'] = prcpl
obs_dict['obs_days'] = obs_days
obs_dict['fmaxt'] = fmaxt
obs_dict['fmint'] = fmint
obs_dict['fprcp'] = fprcp
obs_dict['frobs_days'] = fobs_days
except:
print_exception()
return obs_dict
def getMeta(options):
try:
data_vals = {}
metafile = open(
"%s%s.pkl" % (options["metalocation"], options["area"]), 'rb')
data_vals["meta"] = pickle.load(metafile)
metafile.close()
except IOError:
print "Unable to open a metadata file; accessing lat/lon from gridData"
yest = DateTime.now() + DateTime.RelativeDate(days=-1)
input_dict = {
"sdate": '%d-%02d-%02d' % (yest.year, yest.month, yest.day),
"edate": '%d-%02d-%02d' % (yest.year, yest.month, yest.day),
"grid": 3,
"elems": 'pcpn',
"bbox": options["bbox"],
"meta": 'll'
}
data_vals = getData(input_dict)
return data_vals
def get_downloadtime(stn, station_type):
download_time_dt = miss
try:
if station_type == 'icao':
staid = stn.upper()
else:
if stn[0:3] == "ew_":
stn = stn[3:]
end_date_dt = DateTime.now()
# adjust for DST if necessary (don't worry about this for start_date)
if end_date_dt.dst == 1:
end_date_dt = end_date_dt + DateTime.RelativeDate(hours=-1)
start_date_dt = end_date_dt + DateTime.RelativeDate(
months=-12, hour=0, minute=0, second=0)
# make first chunk just 2 days, 30 days in successive calls as far back as a year
start_period_dt = end_date_dt + DateTime.RelativeDate(days=-2)
end_period_dt = end_date_dt
while end_period_dt >= start_date_dt:
results = get_HourlyData(stn, station_type, start_period_dt,
end_period_dt)
# process data
if results and len(results["data"]) > 0:
temp = results["data"]
for i in range(len(temp) - 1, -1,
-1): # loop back through days
hlydate, hlytemps = temp[i]
for h in range(
len(hlytemps) - 1, -1, -1
): # loop back through hours (h 23 to 0 is hours 24 to 1)
if hlytemps[h] != "M":
hyr, hmn, hdy = hlydate.split("-")
# add one to hour to go from index (23:0) to actual (24:1)
theDate = DateTime.DateTime(
int(hyr), int(hmn), int(hdy),
h) + DateTime.RelativeDate(hours=+1)
download_time_dt = theDate + DateTime.RelativeDate(
hours=+theDate.dst)
return download_time_dt
# reset for previous 30-day chunk
start_period_dt = start_period_dt + DateTime.RelativeDate(days=-30)
end_period_dt = start_period_dt + DateTime.RelativeDate(days=+30)
except Exception, e:
print e
def run_gridSoilTemps(ll,cover,sdate,edate):
import numpy, urllib2
from mx import DateTime
miss = -999
datasetBeginDate = DateTime.DateTime(2017,3,1)
soilTempDirectory = "http://newadata.nrcc.cornell.edu/soilTemps/"
try:
if cover not in ['bare','grass']:
raise gridSoilTempsException("bad cover: %s" % cover)
#allow location provided as comma-separated string
if isinstance(ll, basestring) and ll.find(",") > 0:
ll = map(float, ll.split(","))
if len(ll) == 2:
loc = {"lon": ll[0], "lat": ll[1]}
else:
raise gridSoilTempsException("bad coordinates %s" % str(ll))
gridpt = findNearestGrid(loc)
if not gridpt:
raise gridSoilTempsException("coordinates outside grid")
else:
yy,mm,dd = map(int, sdate.split('-'))
theDate = DateTime.DateTime(yy,mm,dd)
if theDate < datasetBeginDate:
raise gridSoilTempsException('invalid sdate; dataset begins %s-%s-%s' % (datasetBeginDate.year,datasetBeginDate.month,datasetBeginDate.day))
yy,mm,dd = map(int, edate.split('-'))
edate_dt = DateTime.DateTime(yy,mm,dd)
results = {"data": []}
while theDate <= edate_dt:
datestr = "%d-%02d-%02d" % (theDate.year,theDate.month,theDate.day)
soilurl = "%ssoil2in_%s_%s.npy" % (soilTempDirectory, cover, datestr)
try:
soilfile = urllib2.urlopen(soilurl)
soilTemps = numpy.loads(soilfile.read())
dlyval = int(round(soilTemps[gridpt["lat"],gridpt["lon"]], 0))
except:
dlyval = miss
results["data"].append([datestr, dlyval])
theDate += DateTime.RelativeDate(days=+1)
except gridSoilTempsException, e:
results = {"error": str(e)}
def onchange_for_date_end(self, cr, uid, ids, last_medic_exam,
medic_exam_delay, medic_exam,
medic_exam_delay_alert):
if not last_medic_exam and medic_exam:
alert_delay = medic_exam_delay_alert
medic_exam = mdt.DateTime(int(medic_exam[0:4]),
int(medic_exam[5:7]),
int(medic_exam[8:10]))
date = str(medic_exam.year) + '-' + str(
medic_exam.month) + '-' + str(medic_exam.day)
if alert_delay:
date_alert = medic_exam - alert_delay * mdt.oneDay
date_alert = str(date_alert.year) + '-' + str(
date_alert.month) + '-' + str(date_alert.day)
return {
'value': {
'medic_exam': date,
'medic_exam_alert': date_alert
}
}
elif not last_medic_exam and not medic_exam:
return {}
else:
alert_delay = medic_exam_delay_alert
medic_exam = mdt.DateTime(
int(last_medic_exam[0:4]), int(last_medic_exam[5:7]),
int(last_medic_exam[8:10]
)) + medic_exam_delay * mdt.RelativeDate(years=1)
date = str(medic_exam.year) + '-' + str(
medic_exam.month) + '-' + str(medic_exam.day)
if alert_delay:
date_alert = medic_exam - alert_delay * mdt.oneDay
date_alert = str(date_alert.year) + '-' + str(
date_alert.month) + '-' + str(date_alert.day)
return {
'value': {
'medic_exam': date,
'medic_exam_alert': date_alert
}
}
def SOLAR_MAIN(ICAO,sd,ed,stpr0,wthr0,dwpt0,visi0,ccnd0,chgt0,ceil0,tsky0):
# Define units 1=langleys; 2=MJ/m2; 3=W/m2; 4=BTU/ft2
units=1
# Define Temporal resolution of model output
# 1=Daily; 2=Hourly
temp_res=2
# Missing Value and initial value for asos
miss = -999; asos = 0
# Value used when ceiling is "unlimited"
unlimited = 100000.
# Codes for haze and fog occurrences
haze_list=[81,82]
fog_list=[70,71,72,73,74,75,77,78]
######### Obtain the station information ###################################
sinf = stationInfo()
asos_date = sinf.getvar(ICAO, 'asos_date')
lat = sinf.getvar(ICAO, 'lat')
lon = sinf.getvar(ICAO, 'lon')
utc_lapse = sinf.getvar(ICAO, 'gmt_offset')
snow_station = sinf.getvar(ICAO, 'snow_station')
############################################################################
######### Find nearest snow station if not identified ######################
if snow_station == None:
varmajor = 11; detailed_check = 1
snow_station = getNearestCoop (lat,lon,varmajor,sd,ed,detailed_check)
sinf.setvar(ICAO, 'snow_station', snow_station)
############################################################################
######### Set utc_lapse to 5 if not available ##############################
if utc_lapse == -999:
print 'Error: no gmt offset available; using 5'
utc_lapse = 5
############################################################################
######### Needed since MORECS does full days ###############################
if ed[3] > 0:
ed = (DateTime.DateTime(*ed) + DateTime.RelativeDate(days=+1,hour=0)).tuple()[:3]
############################################################################
### Initialize hourly data dictionaries
wx,ceil={},{}
condition,height={},{}
pres,dew,vis,tsky,snow={},{},{},{},{}
for yr in range(sd[0],ed[0]+1):
wx[yr]={}; ceil[yr]={}
condition[yr]={}; height[yr]={}
pres[yr]={}; dew[yr]={}; vis[yr]={}; tsky[yr]={}; snow[yr]={}
for d in range(1,367):
wx[yr][d]={}; ceil[yr][d]={}
condition[yr][d]={}; height[yr][d]={}
pres[yr][d]={}; dew[yr][d]={}; vis[yr][d]={}; tsky[yr][d]={}
for h in range(24):
wx[yr][d][h]=[]
condition[yr][d][h]=[]; height[yr][d][h]=[]
### Determine number of 30-day periods ###
d1=DateTime.Date(sd[0],sd[1],sd[2])
d2=DateTime.Date(ed[0],ed[1],ed[2])
num_periods=int(math.floor((d2.absdate-d1.absdate-1)/30.0))+1
SR_out_dates=[]; SR_out=[]
### Loop through 30-day periods
for period in range(num_periods):
# Create Date List for this period
date_list=[]
ds=DateTime.Date(sd[0],sd[1],sd[2])+DateTime.RelativeDate(days=int(30.0*period))
date_list.append([ds.year,ds.month,ds.day])
for p_inc in range(1,31):
dn = ds + DateTime.RelativeDate(days=p_inc)
if dn <= d2:
date_list.append([dn.year,dn.month,dn.day])
else:
break
################ For obtaining hourly data via TSVars ###################
vsd,ved = date_list[0],date_list[-1]
vsd.append(0)
ved.append(0)
pres_list,pres_dates = getHourlyVars(ICAO, 'stpr', stpr0, vsd, ved)
wx_list,wx_dates = getHourlyVars(ICAO, 'wthr', wthr0, vsd, ved)
dew_list,dew_dates = getHourlyVars(ICAO, 'dwpt', dwpt0, vsd, ved)
vis_list,vis_dates = getHourlyVars(ICAO, 'visi', visi0, vsd, ved)
tsky_list,tsky_dates = getHourlyVars(ICAO, 'tsky', tsky0, vsd, ved)
ceil_list,ceil_dates = getHourlyVars(ICAO, 'ceil', ceil0, vsd, ved)
condition_list,condition_dates = getHourlyVars(ICAO, 'ccnd', ccnd0, vsd, ved)
height_list,height_dates = getHourlyVars(ICAO, 'chgt', chgt0, vsd, ved)
#########################################################################
############### Specify Unlimited Ceiling ('Unl') as 100000 feet ########
############### No longer needed, getting ceiling as float ########
#for c in range(len(ceil_list)):
# if string.find(ceil_list[c],'Unl')!=-1: ceil_list[c]='1000.0'
############### Obtain Snow Cover via TSVars ############################
# Obtain snow cover data for this station
var_min_list=[1,4]
if snow_station != -1:
snow_list,snow_dates,valid_snow = \
solar_routines.GET_DAILY_TSVAR(snow_station,date_list[0],date_list[-1],11,var_min_list)
else:
valid_snow = 0
if valid_snow:
pass
else:
snow_list=[]
snow_dates=date_list
for i in range(len(snow_dates)):
snow_list.append(miss)
#########################################################################
################ Convert lists to dictionaries ##########################
for i in range(len(snow_dates)):
yr=snow_dates[i][0]; month=snow_dates[i][1];
day=snow_dates[i][2]
ds = DateTime.Date(yr,month,day)
j_day = ds.day_of_year
snow[yr][j_day]=float(snow_list[i])
for i in range(len(pres_dates)):
yr=pres_dates[i][0]; month=pres_dates[i][1];
day=pres_dates[i][2]; hr=pres_dates[i][3]
ds = DateTime.Date(yr,month,day)
j_day = ds.day_of_year
if pres_list[i] != miss:
pres[yr][j_day][hr]=pres_list[i]*3387.0/1000.0
else:
pres[yr][j_day][hr]=pres_list[i]
dew[yr][j_day][hr]=dew_list[i]
vis[yr][j_day][hr]=vis_list[i]
tsky[yr][j_day][hr]=tsky_list[i]
# ceil[yr][j_day][hr]=float(ceil_list[i])
ceil[yr][j_day][hr]=ceil_list[i]
condition[yr][j_day][hr]=condition_list[i].value()
height[yr][j_day][hr]=height_list[i].value()
wx[yr][j_day][hr]=wx_list[i].value()
if len(condition[yr][j_day][hr])==0:
condition[yr][j_day][hr]=[-999.0,-999.0,-999.0,-999.0]
for x in range(4):
try:
if condition[yr][j_day][hr][x]<0: condition[yr][j_day][hr][x]=-999.0
except:
condition[yr][j_day][hr].append(5)
if len(height[yr][j_day][hr])==0:
height[yr][j_day][hr]=[-999.0,-999.0,-999.0,-999.0]
for x in range(4):
try:
if height[yr][j_day][hr][x]<0:
height[yr][j_day][hr][x]=-999.0
else:
height[yr][j_day][hr][x]=height[yr][j_day][hr][x]/100.0
except:
height[yr][j_day][hr].append(-999.0)
#########################################################################
## Re-classify model definitions of sky condition 0-9 instead of 1-128 ##
cover=condition; cover_dates=condition_dates
coverage = solar_routines.RECLASS_CCOND(condition,cover,condition_dates,tsky)
#########################################################################
### Loop through hourly data
for d in date_list:
if d==date_list[-1]: continue
trans,cl_alb={},{}
# Check if asos is commissioned at this station for this date (d)
if (d[0]>asos_date[0]) or \
(d[0]==asos_date[0] and d[1]>asos_date[1]) or \
(d[0]==asos_date[0] and d[1]==asos_date[1] and d[2]>asos_date[2]):
asos=1
else:
asos=0
# define julian day
d_cal = DateTime.Date(d[0],d[1],d[2])
d_cal_next = d_cal+DateTime.RelativeDate(days=1)
julian_day=d_cal.day_of_year
julian_day_next=d_cal_next.day_of_year
if len(height[d[0]][julian_day][0]) == 0:
for h in range(24):
sr_date = [d[0],d[1],d[2],h]
SR_out_dates.append(sr_date)
SR_out.append(miss)
continue
# assign snow depth, obtained previously from nearby coop station
try:
snodpth=snow[d[0]][julian_day]
except:
snodpth=miss
try:
snodpth_next=snow[d[0]][julian_day_next]
except:
snodpth_next=miss
# assign snow depth by averaging today's and next day's snow depth
if (snodpth!=miss and snodpth_next!=miss):
sno=int((snodpth+snodpth_next)/2.0)
elif (snodpth==miss and snodpth_next!=miss):
sno=snodpth_next
elif (snodpth!=miss and snodpth_next==miss):
sno=snodpth
else:
sno=0
haze_hourly=[]; fog_hourly=[]
for i in range(24):
numlyr = 0
# determine if fog or haze is present
haze,fog=0,0
for w in wx[d[0]][julian_day][i]:
if w in haze_list: haze=1
if w in fog_list: fog=1
haze_hourly.append(haze); fog_hourly.append(fog)
# If cloud base height is missing, coverage is -BKN, -OVC
# or -X and ceiling is unlimited, assign a height of 20,000 ft
for l in range(3): # loops through lowest 3 cloud layers
if (height[d[0]][julian_day][i][l]<0.0 and \
(coverage[d[0]][julian_day][i][l]==3 or \
coverage[d[0]][julian_day][i][l]==4 or \
coverage[d[0]][julian_day][i][l]==5 or \
coverage[d[0]][julian_day][i][l]==6) and \
ceil[d[0]][julian_day][i]==unlimited):
ceil[d[0]][julian_day][i] = 200.
if height[d[0]][julian_day][i][l]!=miss: numlyr = numlyr+1
# If cloud base height is missing, calls the subroutine ceiling to
# obtain an estimate based on the ceiling height
for l in range(3): # loops through lowest 3 cloud layers
if (height[d[0]][julian_day][i][l]<0.0 and \
coverage[d[0]][julian_day][i][l]!=9 and \
coverage[d[0]][julian_day][i][l]!=0 and \
ceil[d[0]][julian_day][i]!=miss):
zhight=random.random()
height_new = solar_routines.CEILING(height[d[0]][julian_day][i],\
coverage[d[0]][julian_day][i],ceil[d[0]][julian_day][i],zhight)
height[d[0]][julian_day][i]=height_new
break
# Hours with a height given but no coverage will be assigned
# a coverage of obscured
if (numlyr==1 and height[d[0]][julian_day][i][0]!=miss and \
coverage[d[0]][julian_day][i][0]==9 and vis[d[0]][julian_day][i]<=1):
coverage[d[0]][julian_day][i][0] = 7
# call routine to get the cloud transmission values
trans[i],cl_alb[i] = \
solar_routines.TRAN(d[0],d[1],asos,haze,fog,\
vis[d[0]][julian_day][i],height[d[0]][julian_day][i],\
coverage[d[0]][julian_day][i],ceil[d[0]][julian_day][i],miss)
# sys.stdout.write('%s: Trans: ' % d[0:3])
# for kle in range(0,24):
# sys.stdout.write(' %5.2f' % (trans[kle]))
# sys.stdout.write('\n')
# sys.stdout.write('%s Cloud ht:' % d[0:3])
# for kle in range(0,24):
# top = max(height[d[0]][julian_day][kle])
# sys.stdout.write(' %5d' % (int(top)))
# sys.stdout.write('\n')
# call routine to calculate global solar radiation values
sun_top,sun_clear,sun_cloud,zenith = \
solar_routines.SOLAR_CALC_H(d[0],d[1],julian_day,\
pres[d[0]][julian_day],dew[d[0]][julian_day],trans,cl_alb,\
height[d[0]][julian_day],coverage[d[0]][julian_day],\
vis[d[0]][julian_day],sno,haze_hourly, fog_hourly,\
lat,lon,miss,utc_lapse,ICAO,asos)
for h in range(24):
sr_date=[d[0],d[1],d[2],h]
SR_out_dates.append(sr_date)
if sun_cloud[h] == miss or sun_cloud[h] == -99:
# print 'Missing solar',ICAO,sr_date,trans[h],height[d[0]][julian_day][h],coverage[d[0]][julian_day][h],vis[d[0]][julian_day][h],pres[d[0]][julian_day][h],dew[d[0]][julian_day][h],sno,fog_hourly[h],haze_hourly[h]
# print 'Missing solar',ICAO,sr_date,ceil[d[0]][julian_day][h]
SR_out.append(miss)
elif units==1:
SR_out.append(sun_cloud[h]*23.88)
elif units==2:
SR_out.append(sun_cloud[h])
elif units==3:
SR_out.append(sun_cloud[h]/0.0036)
elif units==4:
SR_out.append(sun_cloud[h]*88.054)
else:
pass
return SR_out_dates, SR_out
def run_apple_scab_plots(stn, end_date_dt, greentip, output):
try:
now = DateTime.now()
smry_dict = {}
smry_dict['biofix_name'] = 'Greentip'
daily_data = None
if not end_date_dt: end_date_dt = now
start_date_dt = DateTime.DateTime(end_date_dt.year, 3, 15, 0)
end_date_dt = min(end_date_dt,
DateTime.DateTime(end_date_dt.year, 6, 15, 23))
# greentip can either be passed into this program, read from a file, or estimated from degree day accumulation
if not greentip:
greentip = newaModel.Models().get_biofix(
stn, 'as', end_date_dt.year) #from file
if not greentip:
jan1_dt = DateTime.DateTime(end_date_dt.year, 1, 1)
daily_data, station_name = newaCommon.Base().get_daily(
stn, jan1_dt, end_date_dt)
biofix_dd = phen_events_dict['macph_greentip_43']['dd'][
2] #by degree day accumulation
ret_bf_date, ddaccum, ddmiss = newaModel.Models().accum_degday(
daily_data, jan1_dt, end_date_dt, 'dd43be', biofix_dd, stn,
station_name)
if ret_bf_date: greentip = ret_bf_date
smry_dict['biofix'] = "%s-%s-%s" % (greentip.year, greentip.month,
greentip.day)
# just use observed data (no forecast) in years other than the current
if end_date_dt.year != now.year:
this_year = False
end_date_dt = end_date_dt + DateTime.RelativeDate(days=+6)
else:
this_year = True
# obtain hourly and daily data
start_date_dt = DateTime.DateTime(end_date_dt.year, 3, 1,
1) #Leave this March 1
hourly_data, daily_data, download_time, station_name, avail_vars = newaCommon.Base(
).get_hddata2(stn, start_date_dt, end_date_dt)
smry_dict['station_name'] = station_name
if this_year:
# now add the forecast data
start_fcst_dt = DateTime.DateTime(
*download_time) + DateTime.RelativeDate(hours=+1)
end_fcst_dt = end_date_dt + DateTime.RelativeDate(days=+6)
hourly_data = newaModel.Models().add_hrly_fcst(
stn, hourly_data, start_fcst_dt, end_fcst_dt, True)
daily_data = newaModel.Apple().hrly_to_dly(hourly_data)
else:
start_fcst_dt = end_date_dt + DateTime.RelativeDate(hours=+1)
end_fcst_dt = end_date_dt
# format for plot routine
if greentip:
start_date_grf = greentip + DateTime.RelativeDate(days=-6)
else:
start_date_grf = start_date_dt
obs_dict = tp_for_grf2(daily_data, start_date_grf, start_fcst_dt,
this_year)
# calculate base 0C degree days for ascospore maturity
if greentip:
dd_data = newaCommon.Base().degday_calcs(daily_data, greentip,
end_fcst_dt, 'dd0c',
'prcp')
else:
dd_data = []
if len(dd_data) > 0:
# calculate ascospore maturity and format for plotting
ascospore_dict = ascospore_for_grf(dd_data, daily_data)
else:
ascospore_dict = {}
ascospore_dict['dates'] = []
ascospore_dict['maturity'] = []
ascospore_dict['error'] = []
# produce plot
onLoadFunction = "produce_applescab_graph(%s, %s, %s);" % (
smry_dict, obs_dict, ascospore_dict)
return newaGraph_io.apple_disease_plot(onLoadFunction)
except:
print_exception()
def setup_time(self, eDate):
(year, month, day) = eDate
eTime = apply(DateTime.Date, (year, month, day, 23))
self.eTime = eTime + DateTime.RelativeDate(hours=+1)
self.sTime = DateTime.DateTime(year, 1, 1, 0)
def getLocalFromEST(date):
EST_time = apply(DateTime.Date, date)
localTime = EST_time + DateTime.RelativeDate(hours=+EST_time.dst)
day = localTime.day_of_year
hour = localTime.hour
return (day, hour)
def getLocalFromEST_time(EST_time):
localTime = EST_time + DateTime.RelativeDate(hours=+EST_time.dst)
return localTime
def get_warning_day(self) : self.warning_sTime = self.eTime + DateTime.RelativeDate(days=-14) self.warning_sDay = self.warning_sTime.day_of_year self.warning_eDay = self.eTime.day_of_year
