示例#1
0
def test_simple():
    """ Get nulls for right and top values """
    i, j = iemre.find_ij(iemre.EAST, iemre.NORTH)
    assert i is None
    assert j is None

    i, j = iemre.find_ij(iemre.WEST, iemre.SOUTH)
    assert i == 0
    assert j == 0
示例#2
0
    def test_simple(self):
        """ Get nulls for right and top values """
        i, j = iemre.find_ij(iemre.EAST, iemre.NORTH)
        assert i is None
        assert j is None

        i, j = iemre.find_ij(iemre.WEST, iemre.SOUTH)
        self.assertEqual(i, 0)
        self.assertEqual(j, 0)
示例#3
0
    def test_simple(self):
        """ Get nulls for right and top values """
        i, j = iemre.find_ij(iemre.EAST, iemre.NORTH)
        assert i is None
        assert j is None

        i, j = iemre.find_ij(iemre.WEST, iemre.SOUTH)
        self.assertEqual(i, 0)
        self.assertEqual(j, 0)
示例#4
0
def test_simple():
    """ Get nulls for right and top values """
    i, j = iemre.find_ij(iemre.EAST, iemre.NORTH)
    assert i is None
    assert j is None

    i, j = iemre.find_ij(iemre.WEST, iemre.SOUTH)
    assert i == 0
    assert j == 0
示例#5
0
def load_table(state, date):
    """Update the station table"""
    nt = NetworkTable("%sCLIMATE" % (state, ))
    rows = []
    istoday = (date == datetime.date.today())
    for sid in nt.sts:
        # handled by compute_0000
        if sid[2:] == '0000' or sid[2] == 'C':
            continue
        if istoday and not nt.sts[sid]['temp24_hour'] in range(3, 12):
            # print('skipping %s as is_today' % (sid, ))
            continue
        i, j = iemre.find_ij(nt.sts[sid]['lon'], nt.sts[sid]['lat'])
        nt.sts[sid]['gridi'] = i
        nt.sts[sid]['gridj'] = j
        rows.append(
            {'station': sid, 'gridi': i, 'gridj': j,
             'temp24_hour': nt.sts[sid]['temp24_hour'],
             'precip24_hour': nt.sts[sid]['precip24_hour'],
             'tracks': nt.sts[sid]['attributes'].get(
                 'TRACKS_STATION', '|').split("|")[0]}
        )
    if not rows:
        return
    df = pd.DataFrame(rows)
    df.set_index('station', inplace=True)
    for key in ['high', 'low', 'precip', 'snow', 'snowd']:
        df[key] = None
    return df
示例#6
0
def load_table(state, date):
    """Update the station table"""
    nt = NetworkTable("%sCLIMATE" % (state, ))
    rows = []
    istoday = date == datetime.date.today()
    for sid in nt.sts:
        # handled by compute_0000
        if sid[2:] == "0000" or sid[2] == "C":
            continue
        if istoday and not nt.sts[sid]["temp24_hour"] in range(3, 12):
            continue
        i, j = iemre.find_ij(nt.sts[sid]["lon"], nt.sts[sid]["lat"])
        nt.sts[sid]["gridi"] = i
        nt.sts[sid]["gridj"] = j
        rows.append({
            "station":
            sid,
            "gridi":
            i,
            "gridj":
            j,
            "temp24_hour":
            nt.sts[sid]["temp24_hour"],
            "precip24_hour":
            nt.sts[sid]["precip24_hour"],
            "tracks":
            nt.sts[sid]["attributes"].get("TRACKS_STATION", "|").split("|")[0],
        })
    if not rows:
        return
    df = pd.DataFrame(rows)
    df.set_index("station", inplace=True)
    for key in ["high", "low", "precip", "snow", "snowd"]:
        df[key] = None
    return df
示例#7
0
def tile_extraction(nc, valid, west, south):
    """Do our tile extraction"""
    # update model metadata
    nc.valid = "CFS model: %s" % (valid.strftime("%Y-%m-%dT%H:%M:%SZ"), )
    i, j = iemre.find_ij(west, south)
    islice = slice(i, i + 16)
    jslice = slice(j, j + 16)
    for year in range(1980, valid.year + 1):
        # Current year IEMRE should be substituted for this year's data
        today = datetime.date(year, valid.month, valid.day)
        copy_iemre(nc, valid.year, datetime.date(year, 1, 1), today, islice,
                   jslice)

        # replace CFS!
        if year == valid.year:
            replace_cfs(nc, valid.date(), islice, jslice)
        else:
            # replace rest of year with previous year
            copy_iemre(
                nc,
                year,
                today + datetime.timedelta(days=1),
                datetime.date(year, 12, 31),
                islice,
                jslice,
            )
示例#8
0
def do_var(varname):
    """
    Run our estimator for a given variable
    """
    currentnc = None
    sql = """select day, station from alldata_%s WHERE %s is null
        and day >= '1893-01-01' ORDER by day ASC""" % (state.lower(), varname)
    ccursor.execute(sql)
    for row in ccursor:
        day = row[0]
        station = row[1]
        if station not in nt.sts:
            continue

        sql = """
            SELECT station, %s from alldata_%s WHERE %s is not NULL
            and station in %s and day = '%s'
            """ % (varname, state, varname, tuple(friends[station]), day)
        ccursor2.execute(sql)
        weight = []
        value = []
        for row2 in ccursor2:
            idx = friends[station].index(row2[0])
            weight.append(weights[station][idx])
            value.append(row2[1])

        if len(weight) < 3:
            # Nearest neighbors failed, so lets look at our grided analysis
            # and sample from it
            if currentnc is None or currentnc.title.find(str(day.year)) == -1:
                currentnc = netCDF4.Dataset(("/mesonet/data/iemre/"
                                             "%s_mw_daily.nc") % (day.year,))
            tidx = iemre.daily_offset(datetime.datetime(day.year, day.month,
                                                        day.day))
            iidx, jidx = iemre.find_ij(nt.sts[station]['lon'],
                                       nt.sts[station]['lat'])
            iemreval = currentnc.variables[vnameconv[varname]][tidx, jidx,
                                                               iidx]
            if varname in ('high', 'low'):
                interp = temperature(iemreval, 'K').value('F')
            else:
                interp = distance(iemreval, 'MM').value('IN')
            print '--> Neighbor failure, %s %s %s' % (station, day, varname)
        else:
            mass = sum(weight)
            interp = np.sum(np.array(weight) * np.array(value) / mass)

        dataformat = '%.2f'
        if varname in ['high', 'low']:
            dataformat = '%.0f'
        print(('Set station: %s day: %s varname: %s value: %s'
               ) % (station, day, varname, dataformat % (interp,)))
        sql = """
            UPDATE alldata_%s SET estimated = true, %s = %s WHERE
            station = '%s' and day = '%s'
            """ % (state.lower(), varname,
                   dataformat % (interp,), station, day)
        sql = sql.replace(' nan ', ' null ')
        ccursor2.execute(sql)
示例#9
0
def do_var(varname):
    """
    Run our estimator for a given variable
    """
    currentnc = None
    sql = """select day, station from alldata_%s WHERE %s is null
        and day >= '1893-01-01' ORDER by day ASC""" % (state.lower(), varname)
    ccursor.execute(sql)
    for row in ccursor:
        day = row[0]
        station = row[1]
        if station not in nt.sts:
            continue

        sql = """
            SELECT station, %s from alldata_%s WHERE %s is not NULL
            and station in %s and day = '%s'
            """ % (varname, state, varname, tuple(friends[station]), day)
        ccursor2.execute(sql)
        weight = []
        value = []
        for row2 in ccursor2:
            idx = friends[station].index(row2[0])
            weight.append(weights[station][idx])
            value.append(row2[1])

        if len(weight) < 3:
            # Nearest neighbors failed, so lets look at our grided analysis
            # and sample from it
            if currentnc is None or currentnc.title.find(str(day.year)) == -1:
                currentnc = netCDF4.Dataset(("/mesonet/data/iemre/"
                                             "%s_mw_daily.nc") % (day.year, ))
            tidx = iemre.daily_offset(
                datetime.datetime(day.year, day.month, day.day))
            iidx, jidx = iemre.find_ij(nt.sts[station]['lon'],
                                       nt.sts[station]['lat'])
            iemreval = currentnc.variables[vnameconv[varname]][tidx, jidx,
                                                               iidx]
            if varname in ('high', 'low'):
                interp = temperature(iemreval, 'K').value('F')
            else:
                interp = iemreval / 24.5
            print '--> Neighbor failure, %s %s %s' % (station, day, varname)
        else:
            mass = sum(weight)
            interp = np.sum(np.array(weight) * np.array(value) / mass)

        dataformat = '%.2f'
        if varname in ['high', 'low']:
            dataformat = '%.0f'
        print(('Set station: %s day: %s varname: %s value: %s') %
              (station, day, varname, dataformat % (interp, )))
        sql = """
            UPDATE alldata_%s SET estimated = true, %s = %s WHERE
            station = '%s' and day = '%s'
            """ % (state.lower(), varname, dataformat %
                   (interp, ), station, day)
        sql = sql.replace(' nan ', ' null ')
        ccursor2.execute(sql)
示例#10
0
def load_table():
    """Update the station table"""
    for sid in nt.sts:
        i, j = iemre.find_ij(nt.sts[sid]['lon'], nt.sts[sid]['lat'])
        nt.sts[sid]['gridi'] = i
        nt.sts[sid]['gridj'] = j
        for key in ['high', 'low', 'precip', 'snow', 'snowd']:
            nt.sts[sid][key] = None
示例#11
0
文件: daily.py 项目: raprasad/iem
def main():
    """Do Something Fun!"""
    form = cgi.FormContent()
    ts = datetime.datetime.strptime(form["date"][0], "%Y-%m-%d")
    lat = float(form["lat"][0])
    lon = float(form["lon"][0])
    fmt = form["format"][0]
    if fmt != 'json':
        sys.stdout.write("Content-type: text/plain\n\n")
        sys.stdout.write("ERROR: Service only emits json at this time")
        return

    i, j = iemre.find_ij(lon, lat)
    offset = iemre.daily_offset(ts)

    res = {'data': [], }

    fn = "/mesonet/data/iemre/%s_mw_daily.nc" % (ts.year,)

    sys.stdout.write('Content-type: application/json\n\n')
    if not os.path.isfile(fn):
        sys.stdout.write(json.dumps(res))
        sys.exit()

    if i is None or j is None:
        sys.stdout.write(json.dumps({'error': 'Coordinates outside of domain'}
                                    ))
        return

    nc = netCDF4.Dataset(fn, 'r')

    c2000 = ts.replace(year=2000)
    coffset = iemre.daily_offset(c2000)

    cnc = netCDF4.Dataset("/mesonet/data/iemre/mw_dailyc.nc", 'r')

    res['data'].append({
        'daily_high_f': myrounder(
           datatypes.temperature(
                nc.variables['high_tmpk'][offset, j, i], 'K').value('F'), 1),
        'climate_daily_high_f': myrounder(
           datatypes.temperature(
                cnc.variables['high_tmpk'][coffset, j, i], 'K').value("F"), 1),
        'daily_low_f': myrounder(
           datatypes.temperature(
                nc.variables['low_tmpk'][offset, j, i], 'K').value("F"), 1),
        'climate_daily_low_f': myrounder(
           datatypes.temperature(
                cnc.variables['low_tmpk'][coffset, j, i], 'K').value("F"), 1),
        'daily_precip_in': myrounder(
           nc.variables['p01d'][offset, j, i] / 25.4, 2),
        'climate_daily_precip_in': myrounder(
           cnc.variables['p01d'][coffset, j, i] / 25.4, 2),
      })
    nc.close()
    cnc.close()

    sys.stdout.write(json.dumps(res))
示例#12
0
def tile_extraction(nc, valid, west, south):
    """Do our tile extraction"""
    # update model metadata
    i, j = iemre.find_ij(west, south)
    islice = slice(i, i + 16)
    jslice = slice(j, j + 16)
    for year in range(1980, valid.year + 1):
        copy_iemre(nc, year, datetime.date(year, 1, 1),
                   datetime.date(year, 12, 31), islice, jslice)
示例#13
0
def tile_extraction(nc, valid, west, south):
    """Do our tile extraction"""
    # update model metadata
    i, j = iemre.find_ij(west, south)
    islice = slice(i, i + 16)
    jslice = slice(j, j + 16)
    # Current year IEMRE should be substituted for this year's data
    copy_iemre(nc, valid.year, datetime.date(valid.year, 1, 1), valid, islice,
               jslice)
    replace_cfs(nc, valid, islice, jslice)
示例#14
0
def main(argv):
    """Go Main Go."""
    year = int(argv[1])
    ets = min([datetime.date(year, 12, 31), datetime.date.today()])
    queue = []
    for x0 in np.arange(iemre.WEST, iemre.EAST, 5.):
        for y0 in np.arange(iemre.SOUTH, iemre.NORTH, 5.):
            queue.append([x0, y0])
    for x0, y0 in tqdm(queue, disable=not sys.stdout.isatty()):
        url = (
            "https://power.larc.nasa.gov/cgi-bin/v1/DataAccess.py?"
            "request=execute&identifier=Regional&"
            "parameters=ALLSKY_SFC_SW_DWN&"
            "startDate=%s0101&endDate=%s&userCommunity=SSE&"
            "tempAverage=DAILY&bbox=%s,%s,%s,%s&user=anonymous&"
            "outputList=NETCDF"
        ) % (year, ets.strftime("%Y%m%d"), y0, x0,
             min([y0 + 5., iemre.NORTH]) - 0.1,
             min([x0 + 5., iemre.EAST]) - 0.1)
        req = requests.get(url, timeout=60)
        js = req.json()
        if 'outputs' not in js:
            print(url)
            print(js)
            continue
        fn = js['outputs']['netcdf']
        req = requests.get(fn, timeout=60, stream=True)
        ncfn = '/tmp/power%s.nc' % (year, )
        with open(ncfn, 'wb') as fh:
            for chunk in req.iter_content(chunk_size=1024):
                if chunk:
                    fh.write(chunk)
            fh.close()
        nc = ncopen(ncfn)
        for day, _ in enumerate(nc.variables['time'][:]):
            date = datetime.date(year, 1, 1) + datetime.timedelta(days=day)
            # kwh to MJ/d  3600 * 1000 / 1e6
            data = nc.variables['ALLSKY_SFC_SW_DWN'][day, :, :] * 3.6
            # Sometimes there are missing values?
            if np.ma.is_masked(data):
                data[data.mask] = np.mean(data)
            i, j = iemre.find_ij(x0, y0)
            # resample data is 0.5, iemre is 0.125
            data = np.repeat(np.repeat(data, 4, axis=0), 4, axis=1)
            shp = np.shape(data)
            # print("i: %s j: %s shp: %s" % (i, j, shp))
            renc = ncopen(iemre.get_daily_ncname(year), 'a')
            renc.variables['power_swdn'][
                iemre.daily_offset(date),
                slice(j, j+shp[0]), slice(i, i+shp[1])
            ] = data
            renc.close()
        nc.close()
示例#15
0
def main():
    """Go Main Go"""
    sts = datetime.datetime(2018, 4, 20, 0)
    sts = sts.replace(tzinfo=pytz.utc)
    ets = datetime.datetime(2018, 5, 11, 0)
    ets = ets.replace(tzinfo=pytz.utc)

    nc = ncopen(iemre.get_hourly_ncname(sts.year))
    lons = nc.variables['lon'][:]
    lats = nc.variables['lat'][:]
    running = np.zeros((len(nc.dimensions['lat']), len(nc.dimensions['lon'])))
    maxval = np.zeros((len(nc.dimensions['lat']), len(nc.dimensions['lon'])))
    interval = datetime.timedelta(hours=1)
    now = sts
    i, j = iemre.find_ij(-93.61, 41.99)
    while now < ets:
        offset = iemre.hourly_offset(now)
        p01m = np.sum(nc.variables['p01m'][offset - 24:offset], axis=0)
        # 0.05in is 1.27 mm
        this = np.where(p01m > THRESHOLD, 1, 0)
        running = np.where(this == 1, 0, running + 1)
        maxval = np.where(running > maxval, running, maxval)
        print("%s %s %s" % (now, running[j, i], maxval[j, i]))

        now += interval

    # maxval = numpy.where(domain == 1, maxval, 1.e20)

    m = plot.MapPlot(sector='midwest',
                     title=('Max Period '
                            'between 24 Hour 0.25+ inch Total Precipitation'),
                     subtitle=('Period of 20 Apr - 11 May 2018, '
                               'based on NCEP Stage IV data'))

    extra = lons[-1] + (lons[-1] - lons[-2])
    lons[-1] = extra
    # lons = np.concatenate([lons, [extra, ]])

    extra = lats[-1] + (lats[-1] - lats[-2])
    lats[-1] = extra
    # lats = np.concatenate([lats, [extra, ]])

    lons, lats = np.meshgrid(lons, lats)
    # m.pcolormesh(x, y, maxval / 24.0, numpy.arange(0,25,1), units='days')
    maxval = np.where(maxval > 800, 73., maxval)
    cmap = plt.get_cmap('terrain')
    m.contourf(lons, lats, maxval / 24.0, np.arange(1, 11.1, 1), cmap=cmap,
               units='days', clip_on=False)
    m.postprocess(filename='test.png')
示例#16
0
def service(
    fmt: SupportedFormatsNoGeoJSON,
    date: datetime.date = Query(
        ...,
        description="The CST/CDT date of interest.",
    ),
    lon: float = Query(..., description="Longitude of point of interest"),
    lat: float = Query(..., description="Latitude of point of interest"),
):
    """Do Something Fun!"""
    sts, ets = get_timerange(date)

    i, j = iemre.find_ij(lon, lat)
    df = workflow(sts, ets, i, j)
    return deliver_df(df, fmt)
示例#17
0
def workflow(fn):
    """Do the copy work"""
    oldnc = netCDF4.Dataset(fn)
    newnc = netCDF4.Dataset(iemre.get_daily_ncname(fn[:4]), 'a')
    newnc.set_auto_scale(True)
    i, j = iemre.find_ij(oldnc.variables['lon'][0], oldnc.variables['lat'][0])
    jslice = slice(j, j + oldnc.dimensions['lat'].size * 2)
    islice = slice(i, i + oldnc.dimensions['lon'].size * 2)
    # print("i:%s j:%s %s %s" % (i, j, islice, jslice))
    for vname in tqdm(oldnc.variables):
        if vname in ['time', 'lat', 'lon']:
            continue
        for tstep in oldnc.variables['time'][:]:
            oldgrid = np.repeat(oldnc.variables[vname][tstep, :, :],
                                2, 0).repeat(2, 1)
            newnc.variables[vname][tstep, jslice, islice] = oldgrid
    newnc.close()
示例#18
0
def tile_extraction(nc, valid, west, south, isnewfile):
    """Do our tile extraction"""
    # update model metadata
    nc.valid = "CFS model: %s" % (valid.strftime("%Y-%m-%dT%H:%M:%SZ"), )
    i, j = iemre.find_ij(west, south)
    islice = slice(i, i + 16)
    jslice = slice(j, j + 16)
    for year in range(1980 if isnewfile else valid.year, valid.year + 1):
        tidx0 = (datetime.date(year, 1, 1) - datetime.date(1980, 1, 1)).days
        tidx1 = (datetime.date(year + 1, 1, 1) -
                 datetime.date(1980, 1, 1)).days
        tslice = slice(tidx0, tidx1)
        ncfn = iemre.get_daily_ncname(year)
        if not os.path.isfile(ncfn):
            continue
        renc = ncopen(ncfn)
        # print("tslice: %s jslice: %s islice: %s" % (tslice, jslice, islice))
        nc.variables['tmax'][tslice, :, :] = temperature(
            renc.variables['high_tmpk'][:, jslice, islice], 'K').value('C')
        nc.variables['tmin'][tslice, :, :] = temperature(
            renc.variables['low_tmpk'][:, jslice, islice], 'K').value('C')
        nc.variables['prcp'][tslice, :, :] = (renc.variables['p01d'][:, jslice,
                                                                     islice])
        # MJ/d back to average W/m2
        nc.variables['srad'][tslice, :, :] = (renc.variables['rsds'][:, jslice,
                                                                     islice])
        renc.close()
        if year != valid.year:
            continue
        # replace CFS!
        renc = ncopen(valid.strftime("/mesonet/data/iemre/cfs_%Y%m%d.nc"))
        tidx = iemre.daily_offset(valid + datetime.timedelta(days=1))
        tslice = slice(tidx0 + tidx, tidx1)
        nc.variables['srad'][tslice, :, :] = (
            renc.variables['srad'][tidx:, jslice, islice] * 1000000. / 86400.)
        nc.variables['tmax'][tslice, :, :] = temperature(
            renc.variables['high_tmpk'][tidx:, jslice, islice], 'K').value('C')
        nc.variables['tmin'][tslice, :, :] = temperature(
            renc.variables['low_tmpk'][tidx:, jslice, islice], 'K').value('C')
        nc.variables['prcp'][tslice, :, :] = (renc.variables['p01d'][tidx:,
                                                                     jslice,
                                                                     islice])
        renc.close()
示例#19
0
def application(environ, start_response):
    """Do Something Fun!"""
    form = parse_formvars(environ)
    sts, ets = get_timerange(form)
    lat = float(form.get("lat", 41.99))
    lon = float(form.get("lon", -95.1))
    # fmt = form.get("format", "json")

    headers = [("Content-type", "application/json")]
    start_response("200 OK", headers)

    i, j = iemre.find_ij(lon, lat)
    mckey = "iemre/hourly/%s/%s/%s" % (sts.strftime("%Y%m%d"), i, j)

    mc = memcache.Client(["iem-memcached:11211"], debug=0)
    res = mc.get(mckey)
    if res is None:
        res = workflow(sts, ets, i, j)
        res = json.dumps(res).encode("ascii")
        mc.set(mckey, res, 3600)
    else:
        sys.stderr.write("Using cached %s\n" % (mckey,))

    return [res]
示例#20
0
def service(
    fmt: SupportedFormatsNoGeoJSON,
    sdate: datetime.date = Query(..., description="Start Date."),
    edate: datetime.date = Query(..., description="End Date."),
    lon: float = Query(..., description="Longitude of point of interest"),
    lat: float = Query(..., description="Latitude of point of interest"),
):
    """Go Main Go"""
    # Make sure we aren't in the future
    tsend = datetime.date.today()
    if edate > tsend:
        edate = datetime.date.today() - datetime.timedelta(days=1)

    i, j = iemre.find_ij(lon, lat)
    offset1 = iemre.daily_offset(sdate)
    offset2 = iemre.daily_offset(edate) + 1
    # Get our netCDF vars
    with ncopen(iemre.get_daily_ncname(sdate.year)) as nc:
        hightemp = convert_value(
            nc.variables["high_tmpk"][offset1:offset2, j, i], "degK", "degF"
        )
        high12temp = convert_value(
            nc.variables["high_tmpk_12z"][offset1:offset2, j, i],
            "degK",
            "degF",
        )
        lowtemp = convert_value(
            nc.variables["low_tmpk"][offset1:offset2, j, i], "degK", "degF"
        )
        low12temp = convert_value(
            nc.variables["low_tmpk_12z"][offset1:offset2, j, i], "degK", "degF"
        )
        precip = mm2inch(nc.variables["p01d"][offset1:offset2, j, i])
        precip12 = mm2inch(nc.variables["p01d_12z"][offset1:offset2, j, i])

    # Get our climatology vars
    c2000 = sdate.replace(year=2000)
    coffset1 = iemre.daily_offset(c2000)
    c2000 = edate.replace(year=2000)
    coffset2 = iemre.daily_offset(c2000) + 1
    with ncopen(iemre.get_dailyc_ncname()) as cnc:
        chigh = convert_value(
            cnc.variables["high_tmpk"][coffset1:coffset2, j, i], "degK", "degF"
        )
        clow = convert_value(
            cnc.variables["low_tmpk"][coffset1:coffset2, j, i], "degK", "degF"
        )
        cprecip = mm2inch(
            cnc.variables["p01d"][coffset1:coffset2, j, i],
        )

    if sdate.year > 1980:
        i2, j2 = prismutil.find_ij(lon, lat)
        with ncopen(f"/mesonet/data/prism/{sdate.year}_daily.nc") as nc:
            prism_precip = mm2inch(
                nc.variables["ppt"][offset1:offset2, j2, i2],
            )
    else:
        prism_precip = [None] * (offset2 - offset1)

    if sdate.year > 2000:
        j2 = int((lat - iemre.SOUTH) * 100.0)
        i2 = int((lon - iemre.WEST) * 100.0)
        with ncopen(iemre.get_daily_mrms_ncname(sdate.year)) as nc:
            mrms_precip = mm2inch(
                nc.variables["p01d"][offset1:offset2, j2, i2],
            )
    else:
        mrms_precip = [None] * (offset2 - offset1)

    res = []

    for i in range(0, offset2 - offset1):
        now = sdate + datetime.timedelta(days=i)
        res.append(
            {
                "date": now.strftime("%Y-%m-%d"),
                "mrms_precip_in": clean(mrms_precip[i]),
                "prism_precip_in": clean(prism_precip[i]),
                "daily_high_f": clean(hightemp[i]),
                "12z_high_f": clean(high12temp[i]),
                "climate_daily_high_f": clean(chigh[i]),
                "daily_low_f": clean(lowtemp[i]),
                "12z_low_f": clean(low12temp[i]),
                "climate_daily_low_f": clean(clow[i]),
                "daily_precip_in": clean(precip[i]),
                "12z_precip_in": clean(precip12[i]),
                "climate_daily_precip_in": clean(cprecip[i]),
            }
        )
    return deliver_df(pd.DataFrame(res), fmt)
示例#21
0
# Make sure we aren't in the future
tsend = datetime.date.today()
if ts2.date() >= tsend:
    ts2 = datetime.datetime.now() - datetime.timedelta(days=1)

lat = float(form["lat"][0])
lon = float(form["lon"][0])
if lon < iemre.WEST or lon > iemre.EAST:
    send_error("lon value outside of bounds: %s to %s" %
               (iemre.WEST, iemre.EAST))
if lat < iemre.SOUTH or lat > iemre.NORTH:
    send_error("lat value outside of bounds: %s to %s" %
               (iemre.SOUTH, iemre.NORTH))
fmt = form["format"][0]

i, j = iemre.find_ij(lon, lat)
offset1 = iemre.daily_offset(ts1)
offset2 = iemre.daily_offset(ts2) + 1

# Get our netCDF vars
fp = "/mesonet/data/iemre/%s_mw_daily.nc" % (ts1.year, )
nc = netCDF4.Dataset(fp, 'r')
hightemp = datatypes.temperature(
    nc.variables['high_tmpk'][offset1:offset2, j, i], 'K').value("F")
lowtemp = datatypes.temperature(
    nc.variables['low_tmpk'][offset1:offset2, j, i], 'K').value("F")
precip = nc.variables['p01d'][offset1:offset2, j, i] / 25.4
nc.close()

# Get our climatology vars
c2000 = ts1.replace(year=2000)
示例#22
0
def plotter(fdict):
    """ Go """
    ctx = get_autoplot_context(fdict, get_description())
    ptype = ctx['ptype']
    date = ctx['date']
    varname = ctx['var']
    csector = ctx['csector']
    title = date.strftime("%-d %B %Y")
    mp = MapPlot(sector=('state' if len(csector) == 2 else csector),
                 state=ctx['csector'],
                 axisbg='white',
                 nocaption=True,
                 title='IEM Reanalysis of %s for %s' %
                 (PDICT.get(varname), title),
                 subtitle='Data derived from various NOAA datasets')
    (west, east, south, north) = mp.ax.get_extent(ccrs.PlateCarree())
    i0, j0 = iemre.find_ij(west, south)
    i1, j1 = iemre.find_ij(east, north)
    jslice = slice(j0, j1)
    islice = slice(i0, i1)

    idx0 = iemre.daily_offset(date)
    with ncopen(iemre.get_daily_ncname(date.year)) as nc:
        lats = nc.variables['lat'][jslice]
        lons = nc.variables['lon'][islice]
        cmap = ctx['cmap']
        if varname in ['rsds', 'power_swdn']:
            # Value is in W m**-2, we want MJ
            multi = (86400. / 1000000.) if varname == 'rsds' else 1
            data = nc.variables[varname][idx0, jslice, islice] * multi
            units = 'MJ d-1'
            clevs = np.arange(0, 37, 3.)
            clevs[0] = 0.01
            clevstride = 1
        elif varname in [
                'wind_speed',
        ]:
            data = speed(nc.variables[varname][idx0, jslice, islice],
                         'MPS').value('MPH')
            units = 'mph'
            clevs = np.arange(0, 41, 2)
            clevs[0] = 0.01
            clevstride = 2
        elif varname in ['p01d', 'p01d_12z', 'snow_12z', 'snowd_12z']:
            # Value is in W m**-2, we want MJ
            data = distance(nc.variables[varname][idx0, jslice, islice],
                            'MM').value('IN')
            units = 'inch'
            clevs = np.arange(0, 0.25, 0.05)
            clevs = np.append(clevs, np.arange(0.25, 3., 0.25))
            clevs = np.append(clevs, np.arange(3., 10.0, 1))
            clevs[0] = 0.01
            clevstride = 1
            cmap = stretch_cmap(ctx['cmap'], clevs)
        elif varname in [
                'high_tmpk', 'low_tmpk', 'high_tmpk_12z', 'low_tmpk_12z',
                'avg_dwpk'
        ]:
            # Value is in W m**-2, we want MJ
            data = temperature(nc.variables[varname][idx0, jslice, islice],
                               'K').value('F')
            units = 'F'
            clevs = np.arange(-30, 120, 5)
            clevstride = 2
        elif varname in ['range_tmpk', 'range_tmpk_12z']:
            vname1 = 'high_tmpk%s' % ('_12z'
                                      if varname == 'range_tmpk_12z' else '', )
            vname2 = 'low_tmpk%s' % ('_12z'
                                     if varname == 'range_tmpk_12z' else '', )
            d1 = nc.variables[vname1][idx0, jslice, islice]
            d2 = nc.variables[vname2][idx0, jslice, islice]
            data = (temperature(d1, 'K').value('F') -
                    temperature(d2, 'K').value('F'))
            units = 'F'
            clevs = np.arange(0, 61, 5)
            clevstride = 2

    if np.ma.is_masked(np.max(data)):
        raise ValueError("Data Unavailable")
    x, y = np.meshgrid(lons, lats)
    if ptype == 'c':
        # in the case of contour, use the centroids on the grids
        mp.contourf(x + 0.125,
                    y + 0.125,
                    data,
                    clevs,
                    clevstride=clevstride,
                    units=units,
                    ilabel=True,
                    labelfmt='%.0f',
                    cmap=cmap)
    else:
        x, y = np.meshgrid(lons, lats)
        mp.pcolormesh(x,
                      y,
                      data,
                      clevs,
                      clevstride=clevstride,
                      cmap=cmap,
                      units=units)

    return mp.fig
示例#23
0
    'IA2367': 'DBQ',
    'IA2723': 'EST',
    'IA4106': 'IOW',
    'IA4587': 'LWD',
    'IA5199': 'MIW',
    'IA5235': 'MCW',
    'IA6389': 'OTM',
    'IA7708': 'SUX',
    'IA7844': 'SPW',
    'IA8706': 'ALO',
    }

# Pre-compute the grid location of each climate site
nt = NetworkTable("%sCLIMATE" % (state.upper(),))
for sid in nt.sts.keys():
    i, j = iemre.find_ij(nt.sts[sid]['lon'], nt.sts[sid]['lat'])
    nt.sts[sid]['gridi'] = i
    nt.sts[sid]['gridj'] = j
    for key in ['high', 'low', 'precip', 'snow', 'snowd']:
        nt.sts[sid][key] = None


def estimate_precip(ts):
    """Estimate precipitation based on IEMRE"""
    idx = iemre.daily_offset(ts)
    nc = netCDF4.Dataset("/mesonet/data/iemre/%s_mw_daily.nc" % (ts.year, ),
                         'r')
    grid12 = nc.variables['p01d_12z'][idx, :, :] / 25.4
    grid00 = nc.variables['p01d'][idx, :, :] / 25.4
    nc.close()
示例#24
0
文件: cum.py 项目: tutuhuang/iem
def main():
    """Go main go"""
    os.chdir("/tmp")

    form = cgi.FormContent()
    ts0 = datetime.datetime.strptime(form["date0"][0], "%Y-%m-%d")
    ts1 = datetime.datetime.strptime(form["date1"][0], "%Y-%m-%d")
    base = int(form["base"][0])
    ceil = int(form["ceil"][0])
    # Make sure we aren't in the future
    tsend = datetime.date.today()
    if ts1.date() >= tsend:
        ts1 = tsend - datetime.timedelta(days=1)
        ts1 = datetime.datetime(ts1.year, ts1.month, ts1.day)
    fmt = form["format"][0]

    offset0 = iemre.daily_offset(ts0)
    offset1 = iemre.daily_offset(ts1)

    ncfn = "/mesonet/data/iemre/%s_mw_daily.nc" % (ts0.year, )
    nc = netCDF4.Dataset(ncfn, 'r')

    # 2-D precipitation, inches
    precip = np.sum(nc.variables['p01d'][offset0:offset1, :, :] / 25.4, axis=0)

    # GDD
    H = datatypes.temperature(nc.variables['high_tmpk'][offset0:offset1],
                              'K').value("F")
    H = np.where(H < base, base, H)
    H = np.where(H > ceil, ceil, H)
    L = datatypes.temperature(nc.variables['low_tmpk'][offset0:offset1],
                              'K').value("F")
    L = np.where(L < base, base, L)
    gdd = np.sum((H + L) / 2.0 - base, axis=0)

    nc.close()

    if fmt == 'json':
        # For example: 19013
        ugc = "IAC" + form["county"][0][2:]
        # Go figure out where this is!
        postgis = get_dbconn('postgis')
        pcursor = postgis.cursor()
        pcursor.execute(
            """
        SELECT ST_x(ST_Centroid(geom)), ST_y(ST_Centroid(geom)) from ugcs WHERE
        ugc = %s and end_ts is null
        """, (ugc, ))
        row = pcursor.fetchone()
        lat = row[1]
        lon = row[0]
        (i, j) = iemre.find_ij(lon, lat)
        myGDD = gdd[j, i]
        myPrecip = precip[j, i]
        res = {
            'data': [],
        }
        res['data'].append({
            'gdd': "%.0f" % (myGDD, ),
            'precip': "%.1f" % (myPrecip, ),
            'latitude': "%.4f" % (lat, ),
            'longitude': "%.4f" % (lon, )
        })
        sys.stdout.write('Content-type: application/json\n\n')
        sys.stdout.write(json.dumps(res))

    if fmt == 'shp':
        # Time to create the shapefiles
        basefn = "iemre_%s_%s" % (ts0.strftime("%Y%m%d"), ts1.strftime("%Y%m"))
        w = shapefile.Writer(shapefile.POLYGON)
        w.field('GDD', 'F', 10, 2)
        w.field('PREC_IN', 'F', 10, 2)

        for x in iemre.XAXIS:
            for y in iemre.YAXIS:
                w.poly(parts=[[(x, y), (x, y +
                                        iemre.DY), (x + iemre.DX, y +
                                                    iemre.DY), (x + iemre.DX,
                                                                y), (x, y)]])

        for i in range(len(iemre.XAXIS)):
            for j in range(len(iemre.YAXIS)):
                w.record(gdd[j, i], precip[j, i])
        w.save(basefn)
        # Create zip file, send it back to the clients
        shutil.copyfile("/opt/iem/data/gis/meta/4326.prj",
                        "%s.prj" % (basefn, ))
        z = zipfile.ZipFile("%s.zip" % (basefn, ), 'w', zipfile.ZIP_DEFLATED)
        for suffix in ['shp', 'shx', 'dbf', 'prj']:
            z.write("%s.%s" % (basefn, suffix))
        z.close()

        sys.stdout.write("Content-type: application/octet-stream\n")
        sys.stdout.write(
            ("Content-Disposition: attachment; filename=%s.zip\n\n") %
            (basefn, ))

        sys.stdout.write(file(basefn + ".zip", 'r').read())

        for suffix in ['zip', 'shp', 'shx', 'dbf', 'prj']:
            os.unlink("%s.%s" % (basefn, suffix))
示例#25
0
文件: daily.py 项目: stormchas4/iem
def application(environ, start_response):
    """Do Something Fun!"""
    form = parse_formvars(environ)
    ts = datetime.datetime.strptime(form.get("date", "2019-03-01"), "%Y-%m-%d")
    lat = float(form.get("lat", 41.99))
    lon = float(form.get("lon", -95.1))
    fmt = form.get("format", "json")
    if fmt != "json":
        headers = [("Content-type", "text/plain")]
        start_response("200 OK", headers)
        return [b"ERROR: Service only emits json at this time"]

    i, j = iemre.find_ij(lon, lat)
    offset = iemre.daily_offset(ts)

    res = {"data": []}

    fn = iemre.get_daily_ncname(ts.year)

    headers = [("Content-type", "application/json")]
    start_response("200 OK", headers)

    if not os.path.isfile(fn):
        return [json.dumps(res).encode("ascii")]

    if i is None or j is None:
        data = {"error": "Coordinates outside of domain"}
        return [json.dumps(data).encode("ascii")]

    if ts.year > 1980:
        ncfn = "/mesonet/data/prism/%s_daily.nc" % (ts.year, )
        if not os.path.isfile(ncfn):
            prism_precip = None
        else:
            i2, j2 = prismutil.find_ij(lon, lat)
            with ncopen(ncfn) as nc:
                prism_precip = nc.variables["ppt"][offset, j2, i2] / 25.4
    else:
        prism_precip = None

    if ts.year > 2010:
        ncfn = iemre.get_daily_mrms_ncname(ts.year)
        if not os.path.isfile(ncfn):
            mrms_precip = None
        else:
            j2 = int((lat - iemre.SOUTH) * 100.0)
            i2 = int((lon - iemre.WEST) * 100.0)
            with ncopen(ncfn) as nc:
                mrms_precip = nc.variables["p01d"][offset, j2, i2] / 25.4
    else:
        mrms_precip = None

    c2000 = ts.replace(year=2000)
    coffset = iemre.daily_offset(c2000)

    with ncopen(fn) as nc:
        with ncopen(iemre.get_dailyc_ncname()) as cnc:

            res["data"].append({
                "prism_precip_in":
                myrounder(prism_precip, 2),
                "mrms_precip_in":
                myrounder(mrms_precip, 2),
                "daily_high_f":
                myrounder(
                    datatypes.temperature(
                        nc.variables["high_tmpk"][offset, j, i],
                        "K").value("F"),
                    1,
                ),
                "12z_high_f":
                myrounder(
                    datatypes.temperature(
                        nc.variables["high_tmpk_12z"][offset, j, i],
                        "K").value("F"),
                    1,
                ),
                "climate_daily_high_f":
                myrounder(
                    datatypes.temperature(
                        cnc.variables["high_tmpk"][coffset, j, i],
                        "K").value("F"),
                    1,
                ),
                "daily_low_f":
                myrounder(
                    datatypes.temperature(
                        nc.variables["low_tmpk"][offset, j, i],
                        "K").value("F"),
                    1,
                ),
                "12z_low_f":
                myrounder(
                    datatypes.temperature(
                        nc.variables["low_tmpk_12z"][offset, j, i],
                        "K").value("F"),
                    1,
                ),
                "avg_dewpoint_f":
                myrounder(
                    datatypes.temperature(
                        nc.variables["avg_dwpk"][offset, j, i],
                        "K").value("F"),
                    1,
                ),
                "climate_daily_low_f":
                myrounder(
                    datatypes.temperature(
                        cnc.variables["low_tmpk"][coffset, j, i],
                        "K").value("F"),
                    1,
                ),
                "daily_precip_in":
                myrounder(nc.variables["p01d"][offset, j, i] / 25.4, 2),
                "12z_precip_in":
                myrounder(nc.variables["p01d_12z"][offset, j, i] / 25.4, 2),
                "climate_daily_precip_in":
                myrounder(cnc.variables["p01d"][coffset, j, i] / 25.4, 2),
                "srad_mj":
                myrounder(
                    nc.variables["rsds"][offset, j, i] * 86400.0 / 1000000.0,
                    2,
                ),
                "avg_windspeed_mps":
                myrounder(nc.variables["wind_speed"][offset, j, i], 2),
            })
    return [json.dumps(res).encode("ascii")]
示例#26
0
def main(argv):
    """Go Main Go."""
    year = int(argv[1])
    sts = datetime.date(year, 1, 1)
    ets = min([datetime.date(year, 12, 31), datetime.date.today()])
    current = {}
    now = ets
    while now >= sts:
        ds = iemre.get_grids(now, varnames="power_swdn")
        maxval = ds["power_swdn"].values.max()
        if np.isnan(maxval) or maxval < 0:
            LOG.debug("adding %s as currently empty", now)
            current[now] = {"data": ds, "dirty": False}
        now -= datetime.timedelta(days=1)
    sts = min(list(current.keys()))
    ets = max(list(current.keys()))
    LOG.debug("running between %s and %s", sts, ets)

    queue = []
    for x0 in np.arange(iemre.WEST, iemre.EAST, 5.0):
        for y0 in np.arange(iemre.SOUTH, iemre.NORTH, 5.0):
            queue.append([x0, y0])
    for x0, y0 in tqdm(queue, disable=not sys.stdout.isatty()):
        url = (
            "https://power.larc.nasa.gov/cgi-bin/v1/DataAccess.py?"
            "request=execute&identifier=Regional&"
            "parameters=ALLSKY_SFC_SW_DWN&"
            "startDate=%s&endDate=%s&userCommunity=SSE&"
            "tempAverage=DAILY&bbox=%s,%s,%s,%s&user=anonymous&"
            "outputList=NETCDF"
        ) % (
            sts.strftime("%Y%m%d"),
            ets.strftime("%Y%m%d"),
            y0,
            x0,
            min([y0 + 5.0, iemre.NORTH]) - 0.1,
            min([x0 + 5.0, iemre.EAST]) - 0.1,
        )
        req = exponential_backoff(requests.get, url, timeout=60)
        js = req.json()
        if "outputs" not in js:
            LOG.debug(url)
            LOG.debug(str(js))
            continue
        fn = js["outputs"]["netcdf"]
        req = requests.get(fn, timeout=60, stream=True)
        ncfn = "/tmp/power%s.nc" % (year,)
        with open(ncfn, "wb") as fh:
            for chunk in req.iter_content(chunk_size=1024):
                if chunk:
                    fh.write(chunk)
            fh.close()
        with ncopen(ncfn) as nc:
            for day, _ in enumerate(nc.variables["time"][:]):
                date = sts + datetime.timedelta(days=day)
                if date not in current:
                    continue
                # kwh to MJ/d  3600 * 1000 / 1e6
                data = nc.variables["ALLSKY_SFC_SW_DWN"][day, :, :] * 3.6
                # Sometimes there are missing values?
                if np.ma.is_masked(data):
                    data[data.mask] = np.mean(data)
                i, j = iemre.find_ij(x0, y0)
                # resample data is 0.5, iemre is 0.125
                data = np.repeat(np.repeat(data, 4, axis=0), 4, axis=1)
                data = np.where(data < 0, np.nan, data)
                shp = np.shape(data)
                jslice = slice(j, j + shp[0])
                islice = slice(i, i + shp[1])
                # get currentdata
                present = current[date]["data"]["power_swdn"].values[
                    jslice, islice
                ]
                if present.mean() == data.mean():
                    continue
                current[date]["data"]["power_swdn"].values[
                    jslice, islice
                ] = data
                current[date]["dirty"] = True
    for date in current:
        if not current[date]["dirty"]:
            continue
        LOG.debug("saving %s", date)
        iemre.set_grids(date, current[date]["data"])
        subprocess.call(
            "python ../iemre/db_to_netcdf.py %s"
            % (date.strftime("%Y %m %d"),),
            shell=True,
        )
示例#27
0
import pytz

sts = datetime.datetime(2013,5,1, 0)
sts = sts.replace(tzinfo=pytz.timezone("UTC"))
ets = datetime.datetime(2013,6,10, 0)
ets = ets.replace(tzinfo=pytz.timezone("UTC"))


nc = netCDF4.Dataset('/mesonet/data/iemre/2013_mw_hourly.nc')
lons = nc.variables['lon'][:]
lats = nc.variables['lat'][:]
running = numpy.zeros( (len(nc.dimensions['lat']), len(nc.dimensions['lon'])))
maxval = numpy.zeros( (len(nc.dimensions['lat']), len(nc.dimensions['lon'])))
interval = datetime.timedelta(hours=1)
now = sts
i,j = iemre.find_ij(-93.61, 41.99)
while now < ets:
    offset = iemre.hourly_offset(now)
    p01m = nc.variables['p01m'][offset]
    # 0.05in is 1.27 mm
    this = numpy.where(p01m > 1.27, 1, 0)
    running = numpy.where(this == 1, 0, running + 1)
    maxval = numpy.where(running > maxval, running, maxval)
    print now, running[j,i], maxval[j,i]
    
    now += interval

nc2 = netCDF4.Dataset("/mesonet/data/iemre/state_weights.nc")
domain = nc2.variables['domain'][:]
nc2.close()
maxval = numpy.where(domain == 1, maxval, 1.e20)
示例#28
0
文件: cum.py 项目: stormchas4/iem
def application(environ, start_response):
    """Go main go"""
    os.chdir("/tmp")

    form = parse_formvars(environ)
    ts0 = datetime.datetime.strptime(form.get("date0"), "%Y-%m-%d")
    ts1 = datetime.datetime.strptime(form.get("date1"), "%Y-%m-%d")
    base = int(form.get("base", 50))
    ceil = int(form.get("ceil", 86))
    # Make sure we aren't in the future
    tsend = datetime.date.today()
    if ts1.date() >= tsend:
        ts1 = tsend - datetime.timedelta(days=1)
        ts1 = datetime.datetime(ts1.year, ts1.month, ts1.day)
    fmt = form.get("format")

    offset0 = iemre.daily_offset(ts0)
    offset1 = iemre.daily_offset(ts1)

    with ncopen(iemre.get_daily_ncname(ts0.year)) as nc:

        # 2-D precipitation, inches
        precip = np.sum(nc.variables["p01d"][offset0:offset1, :, :] / 25.4,
                        axis=0)

        # GDD
        H = datatypes.temperature(nc.variables["high_tmpk"][offset0:offset1],
                                  "K").value("F")
        H = np.where(H < base, base, H)
        H = np.where(H > ceil, ceil, H)
        L = datatypes.temperature(nc.variables["low_tmpk"][offset0:offset1],
                                  "K").value("F")
        L = np.where(L < base, base, L)
        gdd = np.sum((H + L) / 2.0 - base, axis=0)

    if fmt == "json":
        # For example: 19013
        ugc = "IAC" + form.get("county")[2:]
        # Go figure out where this is!
        postgis = get_dbconn("postgis")
        pcursor = postgis.cursor()
        pcursor.execute(
            """
        SELECT ST_x(ST_Centroid(geom)), ST_y(ST_Centroid(geom)) from ugcs WHERE
        ugc = %s and end_ts is null
        """,
            (ugc, ),
        )
        row = pcursor.fetchone()
        lat = row[1]
        lon = row[0]
        (i, j) = iemre.find_ij(lon, lat)
        myGDD = gdd[j, i]
        myPrecip = precip[j, i]
        res = {"data": []}
        res["data"].append({
            "gdd": "%.0f" % (myGDD, ),
            "precip": "%.1f" % (myPrecip, ),
            "latitude": "%.4f" % (lat, ),
            "longitude": "%.4f" % (lon, ),
        })
        headers = [("Content-type", "application/json")]
        start_response("200 OK", headers)
        return [json.dumps(res).encode("ascii")]

    # Time to create the shapefiles
    basefn = "iemre_%s_%s" % (ts0.strftime("%Y%m%d"), ts1.strftime("%Y%m"))
    w = shapefile.Writer(basefn)
    w.field("GDD", "F", 10, 2)
    w.field("PREC_IN", "F", 10, 2)

    for x in iemre.XAXIS:
        for y in iemre.YAXIS:
            w.poly([[
                (x, y),
                (x, y + iemre.DY),
                (x + iemre.DX, y + iemre.DY),
                (x + iemre.DX, y),
                (x, y),
            ]])

    for i in range(len(iemre.XAXIS)):
        for j in range(len(iemre.YAXIS)):
            w.record(gdd[j, i], precip[j, i])
    w.close()
    # Create zip file, send it back to the clients
    shutil.copyfile("/opt/iem/data/gis/meta/4326.prj", "%s.prj" % (basefn, ))
    z = zipfile.ZipFile("%s.zip" % (basefn, ), "w", zipfile.ZIP_DEFLATED)
    for suffix in ["shp", "shx", "dbf", "prj"]:
        z.write("%s.%s" % (basefn, suffix))
    z.close()

    headers = [
        ("Content-type", "application/octet-stream"),
        ("Content-Disposition", "attachment; filename=%s.zip" % (basefn, )),
    ]
    start_response("200 OK", headers)
    content = open(basefn + ".zip", "rb").read()
    for suffix in ["zip", "shp", "shx", "dbf", "prj"]:
        os.unlink("%s.%s" % (basefn, suffix))

    return [content]
示例#29
0
文件: cum.py 项目: nemochina2008/iem
if fmt == 'json':
    # For example: 19013
    ugc = "IAC" + form["county"][0][2:]
    # Go figure out where this is!
    postgis = psycopg2.connect(database='postgis', host='iemdb', user='******')
    pcursor = postgis.cursor()
    pcursor.execute(
        """
    SELECT ST_x(ST_Centroid(geom)), ST_y(ST_Centroid(geom)) from ugcs WHERE
    ugc = %s and end_ts is null
    """, (ugc, ))
    row = pcursor.fetchone()
    lat = row[1]
    lon = row[0]
    (i, j) = iemre.find_ij(lon, lat)
    myGDD = gdd[j, i]
    myPrecip = precip[j, i]
    res = {
        'data': [],
    }
    res['data'].append({
        'gdd': "%.0f" % (myGDD, ),
        'precip': "%.1f" % (myPrecip, ),
        'latitude': "%.4f" % (lat, ),
        'longitude': "%.4f" % (lon, )
    })
    sys.stdout.write('Content-type: application/json\n\n')
    sys.stdout.write(json.dumps(res))

if fmt == 'shp':
示例#30
0
def application(environ, start_response):
    """Go Main Go"""
    form = parse_formvars(environ)
    ts1 = datetime.datetime.strptime(form.get("date1"), "%Y-%m-%d")
    ts2 = datetime.datetime.strptime(form.get("date2"), "%Y-%m-%d")
    if ts1 > ts2:
        return [send_error(start_response, "date1 larger than date2")]
    if ts1.year != ts2.year:
        return [
            send_error(start_response, "multi-year query not supported yet...")
        ]
    # Make sure we aren't in the future
    tsend = datetime.date.today()
    if ts2.date() > tsend:
        ts2 = datetime.datetime.now() - datetime.timedelta(days=1)

    lat = float(form.get("lat"))
    lon = float(form.get("lon"))
    if lon < iemre.WEST or lon > iemre.EAST:
        return [
            send_error(
                start_response,
                "lon value outside of bounds: %s to %s"
                % (iemre.WEST, iemre.EAST),
            )
        ]
    if lat < iemre.SOUTH or lat > iemre.NORTH:
        return [
            send_error(
                start_response,
                "lat value outside of bounds: %s to %s"
                % (iemre.SOUTH, iemre.NORTH),
            )
        ]
    # fmt = form["format"][0]

    i, j = iemre.find_ij(lon, lat)
    offset1 = iemre.daily_offset(ts1)
    offset2 = iemre.daily_offset(ts2) + 1

    # Get our netCDF vars
    with ncopen(iemre.get_daily_ncname(ts1.year)) as nc:
        hightemp = datatypes.temperature(
            nc.variables["high_tmpk"][offset1:offset2, j, i], "K"
        ).value("F")
        high12temp = datatypes.temperature(
            nc.variables["high_tmpk_12z"][offset1:offset2, j, i], "K"
        ).value("F")
        lowtemp = datatypes.temperature(
            nc.variables["low_tmpk"][offset1:offset2, j, i], "K"
        ).value("F")
        low12temp = datatypes.temperature(
            nc.variables["low_tmpk_12z"][offset1:offset2, j, i], "K"
        ).value("F")
        precip = nc.variables["p01d"][offset1:offset2, j, i] / 25.4
        precip12 = nc.variables["p01d_12z"][offset1:offset2, j, i] / 25.4

    # Get our climatology vars
    c2000 = ts1.replace(year=2000)
    coffset1 = iemre.daily_offset(c2000)
    c2000 = ts2.replace(year=2000)
    coffset2 = iemre.daily_offset(c2000) + 1
    with ncopen(iemre.get_dailyc_ncname()) as cnc:
        chigh = datatypes.temperature(
            cnc.variables["high_tmpk"][coffset1:coffset2, j, i], "K"
        ).value("F")
        clow = datatypes.temperature(
            cnc.variables["low_tmpk"][coffset1:coffset2, j, i], "K"
        ).value("F")
        cprecip = cnc.variables["p01d"][coffset1:coffset2, j, i] / 25.4

    if ts1.year > 1980:
        i2, j2 = prismutil.find_ij(lon, lat)
        with ncopen("/mesonet/data/prism/%s_daily.nc" % (ts1.year,)) as nc:
            prism_precip = nc.variables["ppt"][offset1:offset2, j2, i2] / 25.4
    else:
        prism_precip = [None] * (offset2 - offset1)

    if ts1.year > 2010:
        j2 = int((lat - iemre.SOUTH) * 100.0)
        i2 = int((lon - iemre.WEST) * 100.0)
        with ncopen(iemre.get_daily_mrms_ncname(ts1.year)) as nc:
            mrms_precip = nc.variables["p01d"][offset1:offset2, j2, i2] / 25.4
    else:
        mrms_precip = [None] * (offset2 - offset1)

    res = {"data": []}

    for i in range(0, offset2 - offset1):
        now = ts1 + datetime.timedelta(days=i)
        res["data"].append(
            {
                "date": now.strftime("%Y-%m-%d"),
                "mrms_precip_in": clean(mrms_precip[i]),
                "prism_precip_in": clean(prism_precip[i]),
                "daily_high_f": clean(hightemp[i]),
                "12z_high_f": clean(high12temp[i]),
                "climate_daily_high_f": clean(chigh[i]),
                "daily_low_f": clean(lowtemp[i]),
                "12z_low_f": clean(low12temp[i]),
                "climate_daily_low_f": clean(clow[i]),
                "daily_precip_in": clean(precip[i]),
                "12z_precip_in": clean(precip12[i]),
                "climate_daily_precip_in": clean(cprecip[i]),
            }
        )

    start_response("200 OK", [("Content-type", "application/json")])
    return [json.dumps(res).encode("ascii")]
示例#31
0
文件: multiday.py 项目: akrherz/iem
# Make sure we aren't in the future
tsend = datetime.date.today()
if ts2.date() >= tsend:
    ts2 = datetime.datetime.now() - datetime.timedelta(days=1)

lat = float(form["lat"][0])
lon = float(form["lon"][0])
if lon < iemre.WEST or lon > iemre.EAST:
    send_error("lon value outside of bounds: %s to %s" % (iemre.WEST,
                                                          iemre.EAST))
if lat < iemre.SOUTH or lat > iemre.NORTH:
    send_error("lat value outside of bounds: %s to %s" % (iemre.SOUTH,
                                                          iemre.NORTH))
fmt = form["format"][0]

i, j = iemre.find_ij(lon, lat)
offset1 = iemre.daily_offset(ts1)
offset2 = iemre.daily_offset(ts2) + 1

# Get our netCDF vars
fp = "/mesonet/data/iemre/%s_mw_daily.nc" % (ts1.year,)
nc = netCDF4.Dataset(fp, 'r')
hightemp = datatypes.temperature(nc.variables['high_tmpk'][offset1:offset2,
                                                           j, i],
                                 'K').value("F")
lowtemp = datatypes.temperature(nc.variables['low_tmpk'][offset1:offset2,
                                                         j, i],
                                'K').value("F")
precip = nc.variables['p01d'][offset1:offset2, j, i] / 25.4
nc.close()
示例#32
0
    # SD6947       | KUNR | RAPID CITY 4NW       | Rapid City

    # Wisconsin
    'WI5479': 'MKE',
    'WI3269': 'GRB',
    'WI7113': 'RHI',
    'WI2428': 'EAU',
    'WI4961': 'MSN',
    'WI4370': 'LSE',
    'WI2428': 'AUW',
    }

# Pre-compute the grid location of each climate site
nt = NetworkTable("%sCLIMATE" % (state.upper(),))
for sid in nt.sts.keys():
    i, j = iemre.find_ij(nt.sts[sid]['lon'], nt.sts[sid]['lat'])
    nt.sts[sid]['gridi'] = i
    nt.sts[sid]['gridj'] = j
    for key in ['high', 'low', 'precip', 'snow', 'snowd']:
        nt.sts[sid][key] = None


def estimate_precip(ts):
    """Estimate precipitation based on IEMRE"""
    idx = iemre.daily_offset(ts)
    nc = netCDF4.Dataset("/mesonet/data/iemre/%s_mw_daily.nc" % (ts.year, ),
                         'r')
    grid12 = nc.variables['p01d_12z'][idx, :, :] / 25.4
    grid00 = nc.variables['p01d'][idx, :, :] / 25.4
    nc.close()
示例#33
0
def main():
    """Do Something Fun!"""
    form = cgi.FieldStorage()
    ts = datetime.datetime.strptime(form.getfirst("date"), "%Y-%m-%d")
    lat = float(form.getfirst("lat"))
    lon = float(form.getfirst("lon"))
    fmt = form.getfirst("format")
    if fmt != 'json':
        ssw("Content-type: text/plain\n\n")
        ssw("ERROR: Service only emits json at this time")
        return

    i, j = iemre.find_ij(lon, lat)
    offset = iemre.daily_offset(ts)

    res = {
        'data': [],
    }

    fn = iemre.get_daily_ncname(ts.year)

    ssw('Content-type: application/json\n\n')
    if not os.path.isfile(fn):
        ssw(json.dumps(res))
        sys.exit()

    if i is None or j is None:
        ssw(json.dumps({'error': 'Coordinates outside of domain'}))
        return

    if ts.year > 1980:
        ncfn = "/mesonet/data/prism/%s_daily.nc" % (ts.year, )
        if not os.path.isfile(ncfn):
            prism_precip = None
        else:
            i2, j2 = prismutil.find_ij(lon, lat)
            with ncopen(ncfn) as nc:
                prism_precip = nc.variables['ppt'][offset, j2, i2] / 25.4
    else:
        prism_precip = None

    if ts.year > 2010:
        ncfn = iemre.get_daily_mrms_ncname(ts.year)
        if not os.path.isfile(ncfn):
            mrms_precip = None
        else:
            j2 = int((lat - iemre.SOUTH) * 100.0)
            i2 = int((lon - iemre.WEST) * 100.0)
            with ncopen(ncfn) as nc:
                mrms_precip = nc.variables['p01d'][offset, j2, i2] / 25.4
    else:
        mrms_precip = None

    nc = ncopen(fn)

    c2000 = ts.replace(year=2000)
    coffset = iemre.daily_offset(c2000)

    cnc = ncopen(iemre.get_dailyc_ncname())

    res['data'].append({
        'prism_precip_in':
        myrounder(prism_precip, 2),
        'mrms_precip_in':
        myrounder(mrms_precip, 2),
        'daily_high_f':
        myrounder(
            datatypes.temperature(nc.variables['high_tmpk'][offset, j, i],
                                  'K').value('F'), 1),
        '12z_high_f':
        myrounder(
            datatypes.temperature(nc.variables['high_tmpk_12z'][offset, j, i],
                                  'K').value('F'), 1),
        'climate_daily_high_f':
        myrounder(
            datatypes.temperature(cnc.variables['high_tmpk'][coffset, j, i],
                                  'K').value("F"), 1),
        'daily_low_f':
        myrounder(
            datatypes.temperature(nc.variables['low_tmpk'][offset, j, i],
                                  'K').value("F"), 1),
        '12z_low_f':
        myrounder(
            datatypes.temperature(nc.variables['low_tmpk_12z'][offset, j, i],
                                  'K').value('F'), 1),
        'avg_dewpoint_f':
        myrounder(
            datatypes.temperature(nc.variables['avg_dwpk'][offset, j, i],
                                  'K').value('F'), 1),
        'climate_daily_low_f':
        myrounder(
            datatypes.temperature(cnc.variables['low_tmpk'][coffset, j, i],
                                  'K').value("F"), 1),
        'daily_precip_in':
        myrounder(nc.variables['p01d'][offset, j, i] / 25.4, 2),
        '12z_precip_in':
        myrounder(nc.variables['p01d_12z'][offset, j, i] / 25.4, 2),
        'climate_daily_precip_in':
        myrounder(cnc.variables['p01d'][coffset, j, i] / 25.4, 2),
        'srad_mj':
        myrounder(nc.variables['rsds'][offset, j, i] * 86400. / 1000000., 2),
        'avg_windspeed_mps':
        myrounder(nc.variables['wind_speed'][offset, j, i], 2),
    })
    nc.close()
    cnc.close()

    ssw(json.dumps(res))
示例#34
0
文件: cum.py 项目: KayneWest/iem
nc.close()

if fmt == 'json':
    # For example: 19013
    ugc = "IAC" + form["county"][0][2:]
    # Go figure out where this is!
    postgis = psycopg2.connect(database='postgis', host='iemdb', user='******')
    pcursor = postgis.cursor()
    pcursor.execute("""
    SELECT ST_x(ST_Centroid(geom)), ST_y(ST_Centroid(geom)) from ugcs WHERE
    ugc = %s and end_ts is null
    """, (ugc,))
    row = pcursor.fetchone()
    lat = row[1]
    lon = row[0]
    (i, j) = iemre.find_ij(lon, lat)
    myGDD = gdd[j, i]
    myPrecip = precip[j, i]
    res = {'data': [], }
    res['data'].append({
                'gdd': "%.0f" % (myGDD,),
                'precip': "%.1f" % (myPrecip,),
                'latitude': "%.4f" % (lat,),
                'longitude': "%.4f" % (lon,)
       })
    sys.stdout.write('Content-type: application/json\n\n')
    sys.stdout.write(json.dumps(res))

if format == 'shp':
    # Time to create the shapefiles
    fp = "iemre_%s_%s" % (ts0.strftime("%Y%m%d"), ts1.strftime("%Y%m"))
示例#35
0
def main():
    """Go Main Go"""
    form = cgi.FieldStorage()
    ts1 = datetime.datetime.strptime(form.getfirst("date1"), "%Y-%m-%d")
    ts2 = datetime.datetime.strptime(form.getfirst("date2"), "%Y-%m-%d")
    if ts1 > ts2:
        send_error("date1 larger than date2")
    if ts1.year != ts2.year:
        send_error("multi-year query not supported yet...")
    # Make sure we aren't in the future
    tsend = datetime.date.today()
    if ts2.date() > tsend:
        ts2 = datetime.datetime.now() - datetime.timedelta(days=1)

    lat = float(form.getfirst("lat"))
    lon = float(form.getfirst("lon"))
    if lon < iemre.WEST or lon > iemre.EAST:
        send_error("lon value outside of bounds: %s to %s" %
                   (iemre.WEST, iemre.EAST))
    if lat < iemre.SOUTH or lat > iemre.NORTH:
        send_error("lat value outside of bounds: %s to %s" %
                   (iemre.SOUTH, iemre.NORTH))
    # fmt = form["format"][0]

    i, j = iemre.find_ij(lon, lat)
    offset1 = iemre.daily_offset(ts1)
    offset2 = iemre.daily_offset(ts2) + 1

    # Get our netCDF vars
    with ncopen(iemre.get_daily_ncname(ts1.year)) as nc:
        hightemp = datatypes.temperature(
            nc.variables['high_tmpk'][offset1:offset2, j, i], 'K').value("F")
        high12temp = datatypes.temperature(
            nc.variables['high_tmpk_12z'][offset1:offset2, j, i],
            'K').value("F")
        lowtemp = datatypes.temperature(
            nc.variables['low_tmpk'][offset1:offset2, j, i], 'K').value("F")
        low12temp = datatypes.temperature(
            nc.variables['low_tmpk_12z'][offset1:offset2, j, i],
            'K').value("F")
        precip = nc.variables['p01d'][offset1:offset2, j, i] / 25.4
        precip12 = nc.variables['p01d_12z'][offset1:offset2, j, i] / 25.4

    # Get our climatology vars
    c2000 = ts1.replace(year=2000)
    coffset1 = iemre.daily_offset(c2000)
    c2000 = ts2.replace(year=2000)
    coffset2 = iemre.daily_offset(c2000) + 1
    cnc = ncopen(iemre.get_dailyc_ncname())
    chigh = datatypes.temperature(
        cnc.variables['high_tmpk'][coffset1:coffset2, j, i], 'K').value("F")
    clow = datatypes.temperature(
        cnc.variables['low_tmpk'][coffset1:coffset2, j, i], 'K').value("F")
    cprecip = cnc.variables['p01d'][coffset1:coffset2, j, i] / 25.4
    cnc.close()

    if ts1.year > 1980:
        nc = ncopen("/mesonet/data/prism/%s_daily.nc" % (ts1.year, ))
        i2, j2 = prismutil.find_ij(lon, lat)
        prism_precip = nc.variables['ppt'][offset1:offset2, j2, i2] / 25.4
        nc.close()
    else:
        prism_precip = [None] * (offset2 - offset1)

    if ts1.year > 2010:
        nc = ncopen(iemre.get_daily_mrms_ncname(ts1.year))
        j2 = int((lat - iemre.SOUTH) * 100.0)
        i2 = int((lon - iemre.WEST) * 100.0)
        mrms_precip = nc.variables['p01d'][offset1:offset2, j2, i2] / 25.4
        nc.close()
    else:
        mrms_precip = [None] * (offset2 - offset1)

    res = {
        'data': [],
    }

    for i in range(0, offset2 - offset1):
        now = ts1 + datetime.timedelta(days=i)
        res['data'].append({
            'date': now.strftime("%Y-%m-%d"),
            'mrms_precip_in': clean(mrms_precip[i]),
            'prism_precip_in': clean(prism_precip[i]),
            'daily_high_f': clean(hightemp[i]),
            '12z_high_f': clean(high12temp[i]),
            'climate_daily_high_f': clean(chigh[i]),
            'daily_low_f': clean(lowtemp[i]),
            '12z_low_f': clean(low12temp[i]),
            'climate_daily_low_f': clean(clow[i]),
            'daily_precip_in': clean(precip[i]),
            '12z_precip_in': clean(precip12[i]),
            'climate_daily_precip_in': clean(cprecip[i])
        })

    ssw('Content-type: application/json\n\n')
    ssw(json.dumps(res))
示例#36
0
def main():
    """Do Something Fun!"""
    form = cgi.FormContent()
    ts = datetime.datetime.strptime(form["date"][0], "%Y-%m-%d")
    lat = float(form["lat"][0])
    lon = float(form["lon"][0])
    fmt = form["format"][0]
    if fmt != 'json':
        sys.stdout.write("Content-type: text/plain\n\n")
        sys.stdout.write("ERROR: Service only emits json at this time")
        return

    i, j = iemre.find_ij(lon, lat)
    offset = iemre.daily_offset(ts)

    res = {'data': [], }

    fn = "/mesonet/data/iemre/%s_mw_daily.nc" % (ts.year,)

    sys.stdout.write('Content-type: application/json\n\n')
    if not os.path.isfile(fn):
        sys.stdout.write(json.dumps(res))
        sys.exit()

    if i is None or j is None:
        sys.stdout.write(json.dumps({'error': 'Coordinates outside of domain'}
                                    ))
        return

    nc = netCDF4.Dataset(fn, 'r')

    c2000 = ts.replace(year=2000)
    coffset = iemre.daily_offset(c2000)

    cnc = netCDF4.Dataset("/mesonet/data/iemre/mw_dailyc.nc", 'r')

    res['data'].append({
        'daily_high_f': myrounder(
           datatypes.temperature(
                nc.variables['high_tmpk'][offset, j, i], 'K').value('F'), 1),
        '12z_high_f': myrounder(
           datatypes.temperature(
                nc.variables['high_tmpk_12z'][offset, j, i],
                'K').value('F'), 1),
        'climate_daily_high_f': myrounder(
           datatypes.temperature(
                cnc.variables['high_tmpk'][coffset, j, i], 'K').value("F"), 1),
        'daily_low_f': myrounder(
           datatypes.temperature(
                nc.variables['low_tmpk'][offset, j, i], 'K').value("F"), 1),
        '12z_low_f': myrounder(
           datatypes.temperature(
                nc.variables['low_tmpk_12z'][offset, j, i],
                'K').value('F'), 1),
        'avg_dewpoint_f': myrounder(
           datatypes.temperature(
                nc.variables['avg_dwpk'][offset, j, i], 'K').value('F'), 1),
        'climate_daily_low_f': myrounder(
           datatypes.temperature(
                cnc.variables['low_tmpk'][coffset, j, i], 'K').value("F"), 1),
        'daily_precip_in': myrounder(
           nc.variables['p01d'][offset, j, i] / 25.4, 2),
        '12z_precip_in': myrounder(
           nc.variables['p01d_12z'][offset, j, i] / 25.4, 2),
        'climate_daily_precip_in': myrounder(
           cnc.variables['p01d'][coffset, j, i] / 25.4, 2),
        'srad_mj': myrounder(
           nc.variables['rsds'][offset, j, i] * 86400. / 1000000., 2),
        'avg_windspeed_mps': myrounder(
           nc.variables['wind_speed'][offset, j, i], 2),
      })
    nc.close()
    cnc.close()

    sys.stdout.write(json.dumps(res))
示例#37
0
def service(
        fmt: SupportedFormatsNoGeoJSON,
        date: datetime.date = Query(..., description="The date of interest."),
        lon: float = Query(..., description="Longitude of point of interest"),
        lat: float = Query(..., description="Latitude of point of interest"),
):
    """Do Something Fun!"""

    i, j = iemre.find_ij(lon, lat)
    offset = iemre.daily_offset(date)

    res = []

    fn = iemre.get_daily_ncname(date.year)

    if date.year > 1980:
        ncfn = f"/mesonet/data/prism/{date.year}_daily.nc"
        if not os.path.isfile(ncfn):
            prism_precip = None
        else:
            i2, j2 = prismutil.find_ij(lon, lat)
            with ncopen(ncfn) as nc:
                prism_precip = mm2inch(nc.variables["ppt"][offset, j2, i2])
    else:
        prism_precip = None

    if date.year > 2000:
        ncfn = iemre.get_daily_mrms_ncname(date.year)
        if not os.path.isfile(ncfn):
            mrms_precip = None
        else:
            j2 = int((lat - iemre.SOUTH) * 100.0)
            i2 = int((lon - iemre.WEST) * 100.0)
            with ncopen(ncfn) as nc:
                mrms_precip = mm2inch(nc.variables["p01d"][offset, j2, i2])
    else:
        mrms_precip = None

    c2000 = date.replace(year=2000)
    coffset = iemre.daily_offset(c2000)

    with ncopen(fn) as nc:
        with ncopen(iemre.get_dailyc_ncname()) as cnc:

            res.append({
                "prism_precip_in":
                myrounder(prism_precip, 2),
                "mrms_precip_in":
                myrounder(mrms_precip, 2),
                "daily_high_f":
                myrounder(
                    convert_value(
                        nc.variables["high_tmpk"][offset, j, i],
                        "degK",
                        "degF",
                    ),
                    1,
                ),
                "12z_high_f":
                myrounder(
                    convert_value(
                        nc.variables["high_tmpk_12z"][offset, j, i],
                        "degK",
                        "degF",
                    ),
                    1,
                ),
                "climate_daily_high_f":
                myrounder(
                    convert_value(
                        cnc.variables["high_tmpk"][coffset, j, i],
                        "degK",
                        "degF",
                    ),
                    1,
                ),
                "daily_low_f":
                myrounder(
                    convert_value(
                        nc.variables["low_tmpk"][offset, j, i],
                        "degK",
                        "degF",
                    ),
                    1,
                ),
                "12z_low_f":
                myrounder(
                    convert_value(
                        nc.variables["low_tmpk_12z"][offset, j, i],
                        "degK",
                        "degF",
                    ),
                    1,
                ),
                "avg_dewpoint_f":
                myrounder(
                    convert_value(
                        nc.variables["avg_dwpk"][offset, j, i],
                        "degK",
                        "degF",
                    ),
                    1,
                ),
                "climate_daily_low_f":
                myrounder(
                    convert_value(
                        cnc.variables["low_tmpk"][coffset, j, i],
                        "degK",
                        "degF",
                    ),
                    1,
                ),
                "daily_precip_in":
                myrounder(mm2inch(nc.variables["p01d"][offset, j, i]), 2),
                "12z_precip_in":
                myrounder(mm2inch(nc.variables["p01d_12z"][offset, j, i]), 2),
                "climate_daily_precip_in":
                myrounder(mm2inch(cnc.variables["p01d"][coffset, j, i]), 2),
                "srad_mj":
                myrounder(
                    nc.variables["rsds"][offset, j, i] * 86400.0 / 1000000.0,
                    2,
                ),
                "avg_windspeed_mps":
                myrounder(nc.variables["wind_speed"][offset, j, i], 2),
            })
    return deliver_df(pd.DataFrame(res), fmt)
示例#38
0
def append_cfs(res, lon, lat):
    """Append on needed CFS data."""
    gridx, gridy = find_ij(lon, lat)
    lastyear = max(res["data"].keys())
    thisyear = datetime.date.today().year
    lastdate = datetime.date(thisyear, 8, 31)
    if lastyear != thisyear:
        # We don't have any data yet for this year, so we add some
        res["data"][thisyear] = {"dates": [], "high": [], "low": [], "rh": []}
    else:
        # shrug
        if res["data"][lastyear]["dates"]:
            lastdate = datetime.datetime.strptime(
                res["data"][thisyear]["dates"][-1], "%Y-%m-%d"
            ).date()
    # go find the most recent CFS 0z file
    valid = datetime.date.today()
    attempt = 0
    while True:
        testfn = valid.strftime("/mesonet/data/iemre/cfs_%Y%m%d00.nc")
        if os.path.isfile(testfn):
            break
        valid -= datetime.timedelta(hours=24)
        attempt += 1
        if attempt > 9:
            return None
    try:
        nc = ncopen(testfn, timeout=NCOPEN_TIMEOUT)
    except Exception as exp:
        LOG.error(exp)
        return None
    if nc is None:
        LOG.debug("Failing %s as nc is None", testfn)
        return None
    high = (
        masked_array(nc.variables["high_tmpk"][:, gridy, gridx], units.degK)
        .to(units.degF)
        .m
    )
    low = (
        masked_array(nc.variables["low_tmpk"][:, gridy, gridx], units.degK)
        .to(units.degF)
        .m
    )
    # RH hack
    # found ~20% bias with this value, so arb addition for now
    rh = (
        relative_humidity_from_dewpoint(
            masked_array(high, units.degF), masked_array(low, units.degF)
        ).m
        * 100.0
        + 20.0
    )
    rh = np.where(rh > 95, 95, rh)
    entry = res["data"][thisyear]
    # lastdate is either August 31 or a date after, so our first forecast
    # date is i+1
    tidx = daily_offset(lastdate + datetime.timedelta(days=1))
    for i in range(tidx, 365):
        lts = datetime.date(thisyear, 1, 1) + datetime.timedelta(days=i)
        if lts.month in [9, 10, 11]:
            entry["dates"].append(lts.strftime("%Y-%m-%d"))
            entry["high"].append(_i(high[i]))
            entry["low"].append(_i(low[i]))
            entry["rh"].append(_i(rh[i]))
    return res
示例#39
0
def plotter(fdict):
    """ Go """
    ctx = get_autoplot_context(fdict, get_description())
    ptype = ctx["ptype"]
    date = ctx["date"]
    varname = ctx["var"]
    csector = ctx["csector"]
    title = date.strftime("%-d %B %Y")
    mp = MapPlot(
        sector=("state" if len(csector) == 2 else csector),
        state=ctx["csector"],
        axisbg="white",
        nocaption=True,
        title="IEM Reanalysis of %s for %s" % (PDICT.get(varname), title),
        subtitle="Data derived from various NOAA datasets",
    )
    (west, east, south, north) = mp.ax.get_extent(ccrs.PlateCarree())
    i0, j0 = iemre.find_ij(west, south)
    i1, j1 = iemre.find_ij(east, north)
    jslice = slice(j0, j1)
    islice = slice(i0, i1)

    idx0 = iemre.daily_offset(date)
    ncfn = iemre.get_daily_ncname(date.year)
    if not os.path.isfile(ncfn):
        raise NoDataFound("No Data Found.")
    with ncopen(ncfn) as nc:
        lats = nc.variables["lat"][jslice]
        lons = nc.variables["lon"][islice]
        cmap = ctx["cmap"]
        if varname in ["rsds", "power_swdn"]:
            # Value is in W m**-2, we want MJ
            multi = (86400.0 / 1000000.0) if varname == "rsds" else 1
            data = nc.variables[varname][idx0, jslice, islice] * multi
            plot_units = "MJ d-1"
            clevs = np.arange(0, 37, 3.0)
            clevs[0] = 0.01
            clevstride = 1
        elif varname in ["wind_speed"]:
            data = (masked_array(
                nc.variables[varname][idx0, jslice, islice],
                units("meter / second"),
            ).to(units("mile / hour")).m)
            plot_units = "mph"
            clevs = np.arange(0, 41, 2)
            clevs[0] = 0.01
            clevstride = 2
        elif varname in ["p01d", "p01d_12z", "snow_12z", "snowd_12z"]:
            # Value is in W m**-2, we want MJ
            data = (masked_array(nc.variables[varname][idx0, jslice, islice],
                                 units("mm")).to(units("inch")).m)
            plot_units = "inch"
            clevs = np.arange(0, 0.25, 0.05)
            clevs = np.append(clevs, np.arange(0.25, 3.0, 0.25))
            clevs = np.append(clevs, np.arange(3.0, 10.0, 1))
            clevs[0] = 0.01
            clevstride = 1
            cmap = stretch_cmap(ctx["cmap"], clevs)
        elif varname in [
                "high_tmpk",
                "low_tmpk",
                "high_tmpk_12z",
                "low_tmpk_12z",
                "avg_dwpk",
        ]:
            # Value is in W m**-2, we want MJ
            data = (masked_array(nc.variables[varname][idx0, jslice, islice],
                                 units("degK")).to(units("degF")).m)
            plot_units = "F"
            clevs = np.arange(-30, 120, 5)
            clevstride = 2
        elif varname in ["range_tmpk", "range_tmpk_12z"]:
            vname1 = "high_tmpk%s" % ("_12z"
                                      if varname == "range_tmpk_12z" else "", )
            vname2 = "low_tmpk%s" % ("_12z"
                                     if varname == "range_tmpk_12z" else "", )
            d1 = nc.variables[vname1][idx0, jslice, islice]
            d2 = nc.variables[vname2][idx0, jslice, islice]
            data = (masked_array(d1, units("degK")).to(units("degF")).m -
                    masked_array(d2, units("degK")).to(units("degF")).m)
            plot_units = "F"
            clevs = np.arange(0, 61, 5)
            clevstride = 2

    if np.ma.is_masked(np.max(data)):
        raise NoDataFound("Data Unavailable")
    x, y = np.meshgrid(lons, lats)
    if ptype == "c":
        # in the case of contour, use the centroids on the grids
        mp.contourf(
            x + 0.125,
            y + 0.125,
            data,
            clevs,
            clevstride=clevstride,
            units=plot_units,
            ilabel=True,
            labelfmt="%.0f",
            cmap=cmap,
        )
    else:
        x, y = np.meshgrid(lons, lats)
        mp.pcolormesh(
            x,
            y,
            data,
            clevs,
            clevstride=clevstride,
            cmap=cmap,
            units=plot_units,
        )

    return mp.fig
示例#40
0
import pytz

sts = datetime.datetime(2015,5,1, 0)
sts = sts.replace(tzinfo=pytz.timezone("UTC"))
ets = datetime.datetime(2015,6,28, 0)
ets = ets.replace(tzinfo=pytz.timezone("UTC"))


nc = netCDF4.Dataset('/mesonet/data/iemre/2015_mw_hourly.nc')
lons = nc.variables['lon'][:]
lats = nc.variables['lat'][:]
running = numpy.zeros( (len(nc.dimensions['lat']), len(nc.dimensions['lon'])))
maxval = numpy.zeros( (len(nc.dimensions['lat']), len(nc.dimensions['lon'])))
interval = datetime.timedelta(hours=1)
now = sts
i,j = iemre.find_ij(-93.61, 41.99)
while now < ets:
    offset = iemre.hourly_offset(now)
    p01m = nc.variables['p01m'][offset]
    # 0.05in is 1.27 mm
    this = numpy.where(p01m > 1.27, 1, 0)
    running = numpy.where(this == 1, 0, running + 1)
    maxval = numpy.where(running > maxval, running, maxval)
    print now, running[j,i], maxval[j,i]
    
    now += interval

nc2 = netCDF4.Dataset("/mesonet/data/iemre/state_weights.nc")
domain = nc2.variables['domain'][:]
nc2.close()
#maxval = numpy.where(domain == 1, maxval, 1.e20)