Exemplo n.º 1
0
parser.add_argument("-w",
                    "--weights",
                    dest="weight_field",
                    help="Field to weight block partition file on.",
                    metavar="VAR")

args = parser.parse_args()

if not args.weight_field:
    print("Weight field missing. Defaulting to unweighted graphs.")
    weighted_parts = False
else:
    weighted_parts = True

dev_null = open(os.devnull, 'w')
grid = NetCDFFile(args.filename, 'r')

nCells = len(grid.dimensions['nCells'])
nEdges = len(grid.dimensions['nEdges'])

nEdgesOnCell = grid.variables['nEdgesOnCell'][:]
cellsOnCell = grid.variables['cellsOnCell'][:] - 1
if weighted_parts:
    try:
        weights = grid.variables[args.weight_field][:]
    except:
        print(args.weight_field,
              ' not found in file. Defaulting to un-weighted partitions.')
        weighted_parts = False
grid.close()
Exemplo n.º 2
0
def region(x, ryield):
    region = NetCDFFile(
        '/global/project/projectdirs/m1602/datasets4.full/arbit_init_state_05x05.nc',
        'r')
    ind = region.variables['REGION_MASK'][:, :]

    area = NetCDFFile(
        '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/gridareahalf_isam.nc',
        'r')
    gridarea1 = area.variables['cell_area']

    isam1 = NetCDFFile(
        '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/luh2area_rcp45_corrcrop.nc',
        'r')
    meareaisam = isam1.variables['fmai_tt'][:, :, :]  #2015-2100
    meareaisam = ma.masked_where(meareaisam <= 0.0, meareaisam)

    isam1 = NetCDFFile(
        '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/luh2area_rcp45_corrcrop.nc',
        'r')
    meareaisam1 = isam1.variables['fmai_tt'][0, :, :]  #2015
    meareaisam1 = ma.masked_where(meareaisam1 <= 0.0, meareaisam1)

    area1 = N.zeros((x, 360, 720))
    ind1 = N.zeros((x, 360, 720))
    gridarea = N.zeros((x, 360, 720))
    for i in range(0, x):
        ind1[i, :, :] = ind[:, :]
        gridarea[i, :, :] = gridarea1[:, :]
        area1[i, :, :] = meareaisam1[:, :]

    ryield = ma.masked_where(ind1 == 0.0, ryield)
    gridarea = ma.masked_where(ind1 == 0.0, gridarea)
    meareaisam = ma.masked_where(ind1 == 0.0, meareaisam)
    area1 = ma.masked_where(ind1 == 0.0, area1)

    isamp = ryield * meareaisam
    name = [
        "Global", "NA", "SA", "EU", "Africa", "PD", "USSR", "China", "SSEA"
    ]

    num = 9

    allarea1 = N.zeros((num))
    allproisam = N.zeros((num, x))
    allyisam = N.zeros((num, x))
    allgrid = N.zeros((num))
    isamgrid = N.zeros((num, x))

    luharea = N.zeros((num, x))
    for idx in range(0, num):
        isampmask = N.zeros((86, 360, 720))
        isamarea = N.zeros((86, 360, 720))
        areak = N.zeros((86, 360, 720))
        areak = gridarea
        isampmask = isamp
        isamarea = meareaisam
        if idx == 5:
            idx = 9
        if idx == 4:
            isampmask = ma.masked_where(ind1 > 5.0, isampmask)
            isamarea = ma.masked_where(ind1 > 5.0, isamarea)
            areak = ma.masked_where(ind1 > 5.0, areak)

            areak = ma.masked_where(ind1 < 4.0, areak)
            isampmask = ma.masked_where(ind1 < 4.0, isampmask)
            isamarea = ma.masked_where(ind1 < 4.0, isamarea)

        elif idx == 0:
            isampmask = ma.masked_where(ind1 == idx, isampmask)
            isamarea = ma.masked_where(ind1 == idx, isamarea)
            areak = ma.masked_where(ind1 == idx, areak)

        else:
            isampmask = ma.masked_where(ind1 != idx, isampmask)
            isamarea = ma.masked_where(ind1 != idx, isamarea)
            areak = ma.masked_where(ind1 != idx, areak)
        if idx == 9:
            idx = 5

        luharea[idx, :] = N.sum(isamarea, axis=(1, 2))

        allproisam[idx, :] = (N.sum(isampmask, axis=(1, 2)))
        allyisam[idx, :] = N.sum(isampmask, axis=(1, 2)) / (N.sum(isamarea,
                                                                  axis=(1, 2)))
        isamgrid[idx, :] = (N.sum(isampmask, axis=(1, 2)) /
                            (N.sum(areak, axis=(1, 2))) * 10000)
    return allproisam, allyisam, isamgrid
Exemplo n.º 3
0
# Will have to run this code everytime you create a new wrfinput_dXX.nc file (i.e. after ./real.exe)
# To run script type:
# python soil_em

from netCDF4 import Dataset as NetCDFFile
import numpy as np

geo_nc = NetCDFFile(
    "/data/hpcdata/users/empott15/PhD/debris_paper_runs/noahLSM_newWRF_WPS/WPS_debris_soilchanged/geo_em.d04.nc",
    "r+")

######################################################
# Adjust dominant top and bottom soil categories
######################################################
var1 = 'SCT_DOM'
geo_nc.variables[var1][:] = np.where(
    geo_nc.variables['LU_INDEX'][:] == 24, 16,
    geo_nc.variables[var1][:])  # if it's clean ice, change soil type to 16
geo_nc.variables[var1][:] = np.where(
    geo_nc.variables['LU_INDEX'][:] == 20, 5, geo_nc.variables[var1]
    [:])  # if it's debris, change soil type to debris (5)
geo_nc.variables[var1][:] = np.where(
    (geo_nc.variables['LU_INDEX'][:] != 24) &
    (geo_nc.variables['LU_INDEX'][:] != 20) &
    (geo_nc.variables[var1][:] == 16), 6,
    geo_nc.variables[var1][:])  #if it's not glacier, change to soil type 6

var2 = 'SCB_DOM'
geo_nc.variables[var2][:] = np.where(geo_nc.variables['LU_INDEX'][:] == 24, 16,
                                     geo_nc.variables[var2][:])
geo_nc.variables[var2][:] = np.where(geo_nc.variables['LU_INDEX'][:] == 20, 5,
Exemplo n.º 4
0
from mpl_toolkits.basemap import Basemap, cm, shiftgrid,interp,maskoceans
from netCDF4 import Dataset as NetCDFFile
import numpy as N
import matplotlib.pyplot as plt
import numpy.ma as ma

mask=NetCDFFile('india_mask.nc','r')
ind = mask.variables['MASK'][:,:]
ind= ma.masked_where(ind<=0.0,ind)


area=NetCDFFile('/scratch2/scratchdirs/tslin2/plot/globalcrop/data/gridareahalf.nc','r')
gridarea = area.variables['cell_area']

isam=NetCDFFile('/scratch2/scratchdirs/tslin2/isam/rice_cheyenne/his_cru/egu/ric_irr_fert/output/ric_irr_fert.nc','r')
lonisam1=isam.variables['lon'][:]
ind,lona11=shiftgrid(180.5,ind,lonisam1,start=False)

ric_i_f=isam.variables['totalyield'][79:109,:,:]
ric_i_f,lona11=shiftgrid(180.5,ric_i_f,lonisam1,start=False)
ric_i_f=ma.masked_where(ric_i_f<=0.0,ric_i_f)
ric_i_f=ma.filled(ric_i_f, fill_value=0.)



isam=NetCDFFile('/scratch2/scratchdirs/tslin2/isam/rice_cheyenne/his_cru/egu/ric_fert/output/ric_fert.nc','r')
ric_f=isam.variables['totalyield'][79:109,:,:]
ric_f,lona11=shiftgrid(180.5,ric_f,lonisam1,start=False)

ric_f=ma.masked_where(ric_f<=0.0,ric_f)
ric_f=ma.filled(ric_f, fill_value=0.)
Exemplo n.º 5
0
from mpl_toolkits.basemap import Basemap, cm, shiftgrid, interp, maskoceans
from netCDF4 import Dataset as NetCDFFile
import numpy as N
import matplotlib.pyplot as plt
import glob
import numpy.ma as ma
from scipy.interpolate import griddata
import matplotlib.colors as colors

area = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/gridareahalf.nc', 'r')
gridarea = area.variables['cell_area'][:, :]
gridlon = area.variables['lon'][:]
gridlat = area.variables['lat'][:]
gridarea, gridlon = shiftgrid(180.5, gridarea, gridlon, start=False)
#print gridlon
nclu = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/maize_AreaYieldProduction.nc',
    'r')
ncvar_maize = nclu.variables['maizeData'][:]
latnc = nclu.variables['latitude'][:]
znc = nclu.variables['level'][:]
lonnc = nclu.variables['longitude'][:]
timenc = nclu.variables['time'][:]
latnc = N.flipud(latnc)

ncvar_maizef = N.zeros((2160, 4320))
ncvar_maizef = ncvar_maize[0, 1, :, :]
ncvar_maize1 = ncvar_maize[0, 4, :, :]
ncvar_mask = N.zeros((2160, 4320))
ncvar_mask = ncvar_maize[0, 0, :, :]
Exemplo n.º 6
0
from mpl_toolkits.basemap import Basemap, cm, shiftgrid, interp
from netCDF4 import Dataset as NetCDFFile
import numpy as N
import math
import matplotlib.pyplot as plt
import glob
import numpy.ma as ma
from scipy.interpolate import griddata
import scipy.stats
from matplotlib.dates import DateFormatter
import datetime
from statsmodels.stats.weightstats import DescrStatsW
import matplotlib.colors as colors

nclu = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/m3yield_isam.nc', 'r')
ncvar_maize = nclu.variables['maizey'][0, :, :]

region1 = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/clm/RCP85_crop_150901.nc',
    'r')
maitrop = region1.variables['maize_trop'][4, :, :]
maitemp = region1.variables['maize_temp'][4, :, :]
maitropi = region1.variables['maize_trop_irrig'][4, :, :]
maitempi = region1.variables['maize_temp_irrig'][4, :, :]
maitrop = ma.masked_where(maitrop <= 0, maitrop)
maitropi = ma.masked_where(maitropi <= 0, maitropi)
maitemp = ma.masked_where(maitemp <= 0, maitemp)
maitempi = ma.masked_where(maitempi <= 0, maitempi)
maitrop = ma.filled(maitrop, fill_value=0.)
maitropi = ma.filled(maitropi, fill_value=0.)
Exemplo n.º 7
0
from mpl_toolkits.basemap import Basemap, cm, shiftgrid, interp, maskoceans
from netCDF4 import Dataset as NetCDFFile
import numpy as N
import matplotlib.pyplot as plt
import glob
import numpy.ma as ma
from scipy.interpolate import griddata
import matplotlib.colors as colors
from scipy.stats import ttest_ind

iizumi = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/iizumi/iizumi.2013JAN29.soybean.1982-2006.30min.nc4',
    'r')
#print iizumi
iyield = iizumi.variables['yield50'][18, :, :]
iarea = iizumi.variables['area'][18, :, :]
la = iizumi.variables['lat'][:]
lo = iizumi.variables['lon'][:]
iyield = N.flipud(iyield)
iarea = N.flipud(iarea)

region1 = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/clm/HistoricalGLM_crop_150901.nc',
    'r')
maitrop = region1.variables['soy_trop'][99, :, :]
maitemp = region1.variables['soy_temp'][99, :, :]
maitropi = region1.variables['soy_trop_irrig'][99, :, :]
maitempi = region1.variables['soy_temp_irrig'][99, :, :]
gridarea = region1.variables['area'][:, :]
maitrop = ma.masked_where(maitrop <= 0, maitrop)
maitrop = ma.filled(maitrop, fill_value=0.)
Exemplo n.º 8
0
from mpl_toolkits.basemap import Basemap, cm, shiftgrid, interp
from netCDF4 import Dataset as NetCDFFile
import numpy as N
import matplotlib.pyplot as plt
import glob
import numpy.ma as ma
from scipy.interpolate import griddata
from scipy.stats import ttest_ind

region1 = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/clm/RCP45_crop_150901.nc',
    'r')
maitrop = region1.variables['maize_trop'][4, :, :]
maitemp = region1.variables['maize_temp'][4, :, :]
maitropi = region1.variables['maize_trop_irrig'][4, :, :]
maitempi = region1.variables['maize_temp_irrig'][4, :, :]
maitrop = ma.masked_where(maitrop <= 0, maitrop)
maitropi = ma.masked_where(maitropi <= 0, maitropi)
maitemp = ma.masked_where(maitemp <= 0, maitemp)
maitempi = ma.masked_where(maitempi <= 0, maitempi)
maitrop = ma.filled(maitrop, fill_value=0.)
maitropi = ma.filled(maitropi, fill_value=0.)
maitemp = ma.filled(maitemp, fill_value=0.)
maitempi = ma.filled(maitempi, fill_value=0.)
maizeto = maitrop + maitemp
maizetoi = maitropi + maitempi
maitoatemp = maitemp + maitempi
maitoatrop = maitrop + maitropi
maizetotal = maizeto + maizetoi
clm = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/clm/clm45rcp45/maizetrop_rcp45_constco2_rf_nofert_0.5x0.5.nc',
Exemplo n.º 9
0
from mpl_toolkits.basemap import Basemap, cm, shiftgrid, interp
from netCDF4 import Dataset as NetCDFFile
import numpy as N
import matplotlib.pyplot as plt
import glob
import numpy.ma as ma
from scipy.interpolate import griddata
import scipy.stats
from matplotlib.dates import DateFormatter
import datetime

country = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/Ctry_halfdeg.nc', 'r')
#print iizumi
coun = country.variables['MASK_Country'][:, :]
#area=NetCDFFile('/scratch2/scratchdirs/tslin2/plot/globalcrop/data/gridareahalf.nc','r')
#gridarea = area.variables['cell_area'][:,:]
#gridlon = area.variables['lon'][:]

#gridarea,gridlon = shiftgrid(180.5,gridarea,gridlon,start=False)


def annualyield(year, couna, counb):
    if year <= 2005:
        bb = year - 1901
        aa = year - 1901
    else:
        bb = 104
        aa = year - 1901

    region1 = NetCDFFile(
from mpl_toolkits.basemap import Basemap, cm, shiftgrid, interp
from netCDF4 import Dataset as NetCDFFile
import numpy as N
import matplotlib.pyplot as plt
import glob
import numpy.ma as ma
from scipy.interpolate import griddata
import matplotlib.colors as colors
from matplotlib.dates import DateFormatter
import datetime

dat = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/isam/maisoy_cheyenne/code/soy1901_2015region.nc',
    'r')
dat1 = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/isam/maisoy_cheyenne/code/soyregion_rcp85.nc',
    'r')
dat2 = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/isam/maisoy_cheyenne/code/soyregion_rcp45.nc',
    'r')

for i in range(1, 6):
    locals()['e{0}p'.format(i)] = dat.variables['e{0}p'.format(i)][:, :]
    locals()['e{0}y'.format(i)] = dat.variables['e{0}y'.format(i)][:, :]
    locals()['e{0}g'.format(i)] = dat.variables['e{0}g'.format(i)][:, :]

    locals()['e{0}p85'.format(i)] = dat1.variables['e{0}p'.format(i)][:, :]
    locals()['e{0}y85'.format(i)] = dat1.variables['e{0}y'.format(i)][:, :]
    locals()['e{0}g85'.format(i)] = dat1.variables['e{0}g'.format(i)][:, :]

    locals()['e{0}p45'.format(i)] = dat2.variables['e{0}p'.format(i)][:, :]
Exemplo n.º 11
0
                  metavar="NUMBER")
options, args = parser.parse_args()
if not options.filename:
    options.filename = 'landice_grid.nc'
    print 'No file specified.  Attempting to use landice_grid.nc'

if not options.afile:
    sys.exit(
        "Error: A restart file from test B5 is required to set up this test.  Specify with -b"
    )

# copy the restart file to be the new input file
shutil.copyfile(options.afile, options.filename)

# Open the file, get needed dimensions
gridfile = NetCDFFile(options.filename, 'r+')
StrLen = len(gridfile.dimensions['StrLen'])
gridfile.variables['xtime'][0, :] = netCDF4.stringtoarr(
    '0000-01-01_00:00:00'.ljust(StrLen), StrLen)
gridfile.variables['simulationStartTime'][:] = netCDF4.stringtoarr(
    '0000-01-01_00:00:00'.ljust(StrLen), StrLen)

# modify melt inputs
gridfile.variables['externalWaterInput'][
    0, :] = gridfile.variables['externalWaterInput'][
        0, :] * 1.0e-12  # Make value at moulin locations tiny but positive
# value for basalMeltInput doesn't matter, because it will be overwritten in the code.
gridfile.close()

print 'Successfully added initial conditions to: ', options.filename
Exemplo n.º 12
0
from mpl_toolkits.basemap import Basemap, cm, shiftgrid, interp, maskoceans
from netCDF4 import Dataset as NetCDFFile
import numpy as N
import matplotlib.pyplot as plt
import numpy.ma as ma
from statsmodels.stats.weightstats import DescrStatsW
import matplotlib.colors as colors
from matplotlib.colors import rgb2hex
from matplotlib.patches import Polygon
import scipy.signal
from mpl_toolkits.axes_grid1.inset_locator import inset_axes
from mpl_toolkits.axes_grid1 import make_axes_locatable

mai = NetCDFFile('mai_irr_fert_pp.nc', 'r')
maiir = mai.variables['g_Precip'][:, 7, 0, :, :]
mai1 = NetCDFFile('mai_fert_pp.nc', 'r')
mai = mai1.variables['g_Precip'][:, 7, 0, :, :]
maiir = ma.masked_where(maiir <= 0.0, maiir)
mai = ma.masked_where(mai <= 0.0, mai)

region = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/Ctry_halfdeg.nc', 'r')
cou = region.variables['MASK_Country'][:, :]
lonab1 = region.variables['Lon'][:]
cou, lonab = shiftgrid(0.5, cou, lonab1, start=True)

region = NetCDFFile(
    '/global/project/projectdirs/m1602/datasets4.full/arbit_init_state_05x05.nc',
    'r')
ind = region.variables['REGION_MASK'][:, :]
lona = region.variables['lon'][:]
Exemplo n.º 13
0
import numpy.ma as ma
import datetime
from mpl_toolkits.basemap import Basemap, addcyclic
from netCDF4 import Dataset as NetCDFFile, num2date

# today's date is default.
if len(sys.argv) > 1:
    YYYYMMDD = sys.argv[1]
else:
    YYYYMMDD = datetime.datetime.today().strftime('%Y%m%d')

# set OpenDAP server URL.
try:
    URLbase = "http://nomad1.ncep.noaa.gov:9090/dods/mrf/mrf"
    URL = URLbase + YYYYMMDD + '/mrf' + YYYYMMDD
    data = NetCDFFile(URL)
except:
    try:
        URLbase = "http://nomad2.ncep.noaa.gov:9090/dods/mrf/mrf"
        URL = URLbase + YYYYMMDD + '/mrf' + YYYYMMDD
        data = NetCDFFile(URL)
    except:
        msg = """
opendap server not providing the requested data.
Try another date by providing YYYYMMDD on command line."""
        raise IOError, msg

# read lats,lons,times.

print data.variables.keys()
latitudes = data.variables['lat']
Exemplo n.º 14
0
from mpl_toolkits.basemap import Basemap, cm
# requires netcdf4-python (netcdf4-python.googlecode.com)
from netCDF4 import Dataset as NetCDFFile
import numpy as np
import matplotlib.pyplot as plt

# plot rainfall from NWS using special SAOitation
# colormap used by the NWS, and included in basemap.

nc = NetCDFFile(
    './subsuf_timmean_fwppiSGa_sao_1800-6699_yearmean_remapcon_1deg_for_density_setT_0-2400.nc'
)
# data from http://water.weather.gov/SAO/
prcpvar = nc.variables['SAO']  #*32140800

data = prcpvar[:]
latcorners = nc.variables['lon'][:]
loncorners = -nc.variables['lat'][:]
#lon_0 = -nc.variables['true_lon'].getValue()
#lat_0 = nc.variables['true_lat'].getValue()
# create figure and axes instances
fig = plt.figure(figsize=(8, 8))
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])
# create polar stereographic Basemap instance.
#m = Basemap(projection='stere',lon_0=lon_0,lat_0=90.,lat_ts=lat_0,\
#            llcrnrlat=latcorners[0],urcrnrlat=latcorners[2],\
#           llcrnrlon=loncorners[0],urcrnrlon=loncorners[2],\
#            rsphere=6371200.,resolution='l',area_thresh=10000)
# draw coastlines, state and country boundaries, edge of map.
lon1 = 2, -12, -50, -110, -89,
lon2 = 8, -2, -40, -80, -60
Exemplo n.º 15
0
from mpl_toolkits.basemap import Basemap, cm
from netCDF4 import Dataset as NetCDFFile
import numpy as np
import matplotlib.pyplot as plt

# 使用NWS的特殊降水色彩映射在地图投影中绘制NWS的降雨图

nc = NetCDFFile('examples/nws_precip_conus_20061222.nc')
# 数据来自 http://water.weather.gov/precip/
prcpvar = nc.variables['amountofprecip']
data = 0.01 * prcpvar[:]
latcorners = nc.variables['lat'][:]
loncorners = -nc.variables['lon'][:]
lon_0 = -nc.variables['true_lon'].getValue()
lat_0 = nc.variables['true_lat'].getValue()

fig = plt.figure(figsize=(8, 8))
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])
# 创建地图投影
m = Basemap(projection='stere',lon_0=lon_0,lat_0=90.,lat_ts=lat_0,\
            llcrnrlat=latcorners[0],urcrnrlat=latcorners[2],\
            llcrnrlon=loncorners[0],urcrnrlon=loncorners[2],\
            rsphere=6371200.,resolution='l',area_thresh=10000)
m.drawcoastlines()

parallels = np.arange(0., 90, 10.)
m.drawparallels(parallels, labels=[1, 0, 0, 0], fontsize=10)
meridians = np.arange(180., 360., 10.)
m.drawmeridians(meridians, labels=[0, 0, 0, 1], fontsize=10)
ny = data.shape[0]
nx = data.shape[1]
Exemplo n.º 16
0
def annualyield(year, couna, counb):
    if year <= 2005:
        bb = year - 1901
        aa = year - 1901
    else:
        bb = 104
        aa = year - 1901

    region1 = NetCDFFile(
        '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/clm/HistoricalGLM_crop_150901.nc',
        'r')
    maitrop = region1.variables['soy_trop'][bb, :, :]
    maitemp = region1.variables['soy_temp'][bb, :, :]
    maitropi = region1.variables['soy_trop_irrig'][bb, :, :]
    maitempi = region1.variables['soy_temp_irrig'][bb, :, :]
    gridarea = region1.variables['area'][:, :]
    maitrop = ma.masked_where(maitrop <= 0, maitrop)
    maitrop = ma.filled(maitrop, fill_value=0.)
    maitemp = ma.masked_where(maitemp <= 0, maitemp)
    maitemp = ma.filled(maitemp, fill_value=0.)

    maitropi = ma.masked_where(maitropi <= 0, maitropi)
    maitropi = ma.filled(maitropi, fill_value=0.)
    maitempi = ma.masked_where(maitempi <= 0, maitempi)
    maitempi = ma.filled(maitempi, fill_value=0.)
    maizetor = maitrop + maitemp
    maizetoi = maitropi + maitempi
    maizeto = maitrop + maitemp + maitropi + maitempi

    clm = NetCDFFile(
        '/scratch2/scratchdirs/tslin2/isam/cheyenne/plot/finalyield/clm/clm45his_soyscaleifyield.nc',
        'r')
    clmtropf = clm.variables['yield'][bb, :, :]
    clmtropf = ma.masked_where(clmtropf <= 0, clmtropf)
    clmtropf = ma.filled(clmtropf, fill_value=0.)

    clm2 = NetCDFFile(
        '/scratch2/scratchdirs/tslin2/isam/cheyenne/plot/finalyield/clm/clm45his_soyscaleiyield.nc',
        'r')
    clmtropf1 = clm2.variables['yield'][bb, :, :]
    clmtropf1 = ma.masked_where(clmtropf1 <= 0, clmtropf1)
    clmtropf1 = ma.filled(clmtropf1, fill_value=0.)

    clm3n = NetCDFFile(
        '/scratch2/scratchdirs/tslin2/isam/cheyenne/plot/finalyield/isam/heat/isamhis_soyscaleiyield_heat.nc',
        'r')
    isammai = clm3n.variables['yield'][bb, :, :]
    isammai = ma.masked_where(isammai <= 0, isammai)
    isammai = ma.filled(isammai, fill_value=0.)

    clm3n1 = NetCDFFile(
        '/scratch2/scratchdirs/tslin2/isam/cheyenne/plot/finalyield/isam/heat/isamhis_soyscaleifyield_heat.nc',
        'r')
    isamcrumai = clm3n1.variables['yield'][bb, :, :]
    isamcrumai = ma.masked_where(isamcrumai <= 0, isamcrumai)
    isamcrumai = ma.filled(isamcrumai, fill_value=0.)

    clm3n2 = NetCDFFile(
        '/scratch2/scratchdirs/tslin2/isam/cheyenne/plot/finalyield/isam/heat/fertfao/new1/isamhiscru_soyscaleiyield_fertfao_new1_long.nc',
        'r')
    isamcrumai2 = clm3n2.variables['yield'][aa, :, :]
    isamcrumai2 = ma.masked_where(isamcrumai2 <= 0, isamcrumai2)
    isamcrumai2 = ma.filled(isamcrumai2, fill_value=0.)

    clm3n3 = NetCDFFile(
        '/scratch2/scratchdirs/tslin2/isam/cheyenne/plot/finalyield/isam/heat/fertall/isamhis_soyscaleiyield_heat_fertall.nc',
        'r')
    isamcrumai3 = clm3n3.variables['yield'][bb, :, :]
    isamcrumai3 = ma.masked_where(isamcrumai3 <= 0, isamcrumai3)
    isamcrumai3 = ma.filled(isamcrumai3, fill_value=0.)

    yieldclm1 = 0
    yieldclm = 0.
    yieldisam = 0.
    yieldisamc = 0.
    yieldisamc2 = 0.
    yieldisamc3 = 0.

    a = 0
    harea = 0
    yieldc1 = 0
    yieldc = 0.
    yieldi = 0.
    yieldic = 0.
    yieldic2 = 0.
    yieldic3 = 0.

    #USA 11501~11550
    for xx in range(0, 360):
        for yy in range(0, 720):
            if coun[xx, yy] >= couna and coun[xx, yy] <= counb:
                harea = maizeto[xx, yy] * gridarea[xx, yy] + harea
                yieldclm1 = (clmtropf1[xx, yy] * maizeto[xx, yy] *
                             gridarea[xx, yy]) + yieldclm1

                yieldclm = (clmtropf[xx, yy] * maizeto[xx, yy] *
                            gridarea[xx, yy]) + yieldclm
                yieldisam = (isammai[xx, yy] * maizeto[xx, yy] *
                             gridarea[xx, yy]) + yieldisam
                yieldisamc = (isamcrumai[xx, yy] * maizeto[xx, yy] *
                              gridarea[xx, yy]) + yieldisamc
                yieldisamc2 = (isamcrumai2[xx, yy] * maizeto[xx, yy] *
                               gridarea[xx, yy]) + yieldisamc2
                yieldisamc3 = (isamcrumai3[xx, yy] * maizeto[xx, yy] *
                               gridarea[xx, yy]) + yieldisamc3

                a = a + 1
    yieldc1 = yieldclm1 / harea
    yieldc = yieldclm / harea
    yieldi = yieldisam / harea
    yieldic = yieldisamc / harea
    yieldic2 = yieldisamc2 / harea
    yieldic3 = yieldisamc3 / harea

    return harea, yieldc, yieldi, yieldic, yieldclm, yieldisam, yieldisamc, yieldic2, yieldic3, yieldisamc2, yieldisamc3, yieldc1
Exemplo n.º 17
0
from mpl_toolkits.basemap import Basemap, cm, shiftgrid, interp
from netCDF4 import Dataset as NetCDFFile
import numpy as N
import matplotlib.pyplot as plt
import glob
import numpy.ma as ma
from scipy.interpolate import griddata
import matplotlib.colors as colors
area1 = NetCDFFile(
    '/project/projectdirs/m1602/datasets4.full/surfdata_05x05.nc', 'r')
mask = area1.variables['REGION_MASK_CRU_NCEP'][:, :]

area = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/gridareahalf_isam.nc',
    'r')
gridarea1 = area.variables['cell_area'][:, :]
gridlon = area.variables['lon'][:]
gridlat = area.variables['lat'][:]
#print gridlon
nclu = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/m3yield_isam.nc', 'r')
ncvar_maize = nclu.variables['soyy'][0, :, :]
marea = nclu.variables['soy_area'][0, :, :]

region1 = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/isam/maisoy_cheyenne/code/isamhiscru_soy_luh2.nc',
    'r')
maitrop = region1.variables['area'][95:105, :, :]
mailu = region1.variables['area'][0, :, :]
lonisam1 = region1.variables['lon'][:]
maitrop = ma.masked_where(maitrop <= 0, maitrop)
Exemplo n.º 18
0
from mpl_toolkits.basemap import Basemap, cm, shiftgrid, interp
from netCDF4 import Dataset as NetCDFFile
import numpy as N
import matplotlib.pyplot as plt
import glob
import numpy.ma as ma
from scipy.interpolate import griddata
from scipy.stats import ttest_ind

region1 = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/clm/RCP85_crop_150901.nc',
    'r')
maitrop = region1.variables['soy_trop'][4, :, :]
maitemp = region1.variables['soy_temp'][4, :, :]
maitropi = region1.variables['soy_trop_irrig'][4, :, :]
maitempi = region1.variables['soy_temp_irrig'][4, :, :]
maitrop = ma.masked_where(maitrop <= 0, maitrop)
maitropi = ma.masked_where(maitropi <= 0, maitropi)
maitemp = ma.masked_where(maitemp <= 0, maitemp)
maitempi = ma.masked_where(maitempi <= 0, maitempi)
maitrop = ma.filled(maitrop, fill_value=0.)
maitropi = ma.filled(maitropi, fill_value=0.)
maitemp = ma.filled(maitemp, fill_value=0.)
maitempi = ma.filled(maitempi, fill_value=0.)
maizeto = maitrop + maitemp
maizetoi = maitropi + maitempi
maitoatemp = maitemp + maitempi
maitoatrop = maitrop + maitropi
maizetotal = maizeto + maizetoi
clm = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/clm/clm45rcp85/soytrop_rcp85_constco2_rf_nofert_0.5x0.5.nc',
Exemplo n.º 19
0
from mpl_toolkits.basemap import Basemap, cm, shiftgrid, interp
from netCDF4 import Dataset as NetCDFFile
import numpy as N
import matplotlib.pyplot as plt
import glob
import numpy.ma as ma
from scipy.interpolate import griddata
from scipy.stats import ttest_ind

region1 = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/clm/RCP85_crop_150901.nc',
    'r')
maitrop = region1.variables['soy_trop'][4, :, :]
maitemp = region1.variables['soy_temp'][4, :, :]
maitropi = region1.variables['soy_trop_irrig'][4, :, :]
maitempi = region1.variables['soy_temp_irrig'][4, :, :]
maitrop = ma.masked_where(maitrop <= 0, maitrop)
maitropi = ma.masked_where(maitropi <= 0, maitropi)
maitemp = ma.masked_where(maitemp <= 0, maitemp)
maitempi = ma.masked_where(maitempi <= 0, maitempi)
maitrop = ma.filled(maitrop, fill_value=0.)
maitropi = ma.filled(maitropi, fill_value=0.)
maitemp = ma.filled(maitemp, fill_value=0.)
maitempi = ma.filled(maitempi, fill_value=0.)
maizeto = maitrop + maitemp
maizetoi = maitropi + maitempi
maitoatemp = maitemp + maitempi
maitoatrop = maitrop + maitropi
maizetotal = maizeto + maizetoi
#clm=NetCDFFile('/scratch2/scratchdirs/tslin2/plot/globalcrop/data/clm/clm45rcp85/soytrop_rcp85_constco2_rf_nofert_0.5x0.5.nc','r')
#clm=NetCDFFile('/scratch2/scratchdirs/tslin2/plot/globalcrop/data/clm/clm45rcp85/soytrop_rcp85_co2_rf_nofert_0.5x0.5.nc','r')
Exemplo n.º 20
0
from mpl_toolkits.basemap import Basemap, cm, shiftgrid, interp, maskoceans
from netCDF4 import Dataset as NetCDFFile
import numpy as N
import matplotlib.pyplot as plt
import numpy.ma as ma
import matplotlib.colors as colors
import matplotlib.patches as mpatches
from matplotlib.collections import LineCollection
import matplotlib.colorbar as colorbar
area = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/gridareahalf.nc', 'r')
gridarea = area.variables['cell_area']
#1997-2003
area = NetCDFFile('c3_flood.nc', 'r')
flood = N.average(area.variables['flood'][1147:1154, :, :], axis=0)
area = NetCDFFile('c3ann.nc', 'r')
c3ann = N.average(area.variables['c3ann'][1147:1154, :, :], axis=0)
#print flood.shape
longf = area.variables['lon'][:]
flood, lona11 = shiftgrid(180.5, flood, longf, start=False)
c3ann, lona11 = shiftgrid(180.5, c3ann, longf, start=False)

#print lona11
nclu = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/rice_AreaYieldProduction.nc',
    'r')
ncvar_m = nclu.variables['riceData'][0, 0, :, :]
ncvar_y = nclu.variables['riceData'][0, 1, :, :]
ncvar_a = nclu.variables['riceData'][0, 4, :, :]
ncvar_p = nclu.variables['riceData'][0, 5, :, :]
Exemplo n.º 21
0
def mpas_to_triangle(mpasfile, trifile):
    """
    Script to convert from MPAS netCDF format to the Triangle format:
    https://www.cs.cmu.edu/~quake/triangle.node.html
    https://www.cs.cmu.edu/~quake/triangle.ele.html

    Parameters
    ----------
    mpasfile : str
        The path to an MPAS mesh in NetCDF format

    trifile : str
        The prefix for the Triangle output files.  Files with extensions
        ``.node`` and ``.ele`` will be produced.

    Only works for planar meshes.
    """
    fin = NetCDFFile(mpasfile, 'r')
    if fin.on_a_sphere == "YES":
        sys.abort("ERROR: This script only works for planar meshes!")

    if len(fin.dimensions['vertexDegree']) != 3:
        sys.abort("ERROR: This script only works for vertexDegree of 3!")

    nCells = len(fin.dimensions['nCells'])
    nVertices = len(fin.dimensions['nVertices'])

    xCell = fin.variables['xCell'][:]
    yCell = fin.variables['yCell'][:]
    ConC = fin.variables['cellsOnCell'][:]
    nConC = fin.variables['nEdgesOnCell'][:]
    ConV = fin.variables['cellsOnVertex'][:]

    # create node file
    fnode = open(trifile + ".node", 'w')
    # write node file header:   First line: <# of vertices> <dimension (must
    # be 2)> <# of attributes> <# of boundary markers (0 or 1)>
    fnode.write("{:d} 2 0 1\n".format(nCells))
    # Remaining lines: <vertex #> <x> <y> [attributes] [boundary marker]
    for i in range(nCells):
        if ConC[i, 0:nConC[i]].min() == 0:
            isBdy = 1
        else:
            isBdy = 0
        fnode.write(
            "{:d} {:f} {:f} {:d}\n".format(
                i + 1,
                xCell[i],
                yCell[i],
                isBdy))
    fnode.write("# Generated from MPAS file: {}\n".format(mpasfile))
    fnode.close()

    # create ele file
    fele = open(trifile + ".ele", "w")

    # calculate number of non-degenerate triangles
    numtri = 0
    for i in range(nVertices):
        if ConV[i, :].min() > 0:
            numtri += 1

    # write ele file header:  First line: <# of triangles> <nodes per
    # triangle> <# of attributes>
    fele.write("{:d} 3 0\n".format(numtri))
    # Remaining lines: <triangle #> <node> <node> <node> ... [attributes]
    cnt = 0
    for i in range(nVertices):
        # write non-generate triangles only
        if ConV[i, :].min() > 0:
            cnt += 1
            fele.write("{:d} {:d} {:d} {:d}\n".format(
                cnt, ConV[i, 0], ConV[i, 1], ConV[i, 2]))
    fele.write("# Generated from MPAS file: {}\n".format(mpasfile))
    fele.close()

    fin.close()
    print("Conversion complete.")
Exemplo n.º 22
0
def process_file(geometry, dataElement, statType, precipVar, s3_bucket, key):

    districts = geometry["boundaries"]
    numDists = len(districts)

    #    print("key " + key)
    # strip off directory from key for temp file
    key_split = key.split('/')
    download_fn = key_split[len(key_split) - 1]
    s3.Bucket(s3_bucket).download_file(key, "/tmp/" + download_fn)
    nc = NetCDFFile("/tmp/" + download_fn)

    # --Pull out the needed variables, lat/lon, time and precipitation.  These subsetted files only have precip param.
    lat = nc.variables['lat'][:]
    lon = nc.variables['lon'][:]
    dayssince1970 = nc.variables['time'][...]
    #    print("dayssince1970 ", dayssince1970[0])

    StartDate = "1/1/70"
    date_1 = datetime.datetime.strptime(StartDate, "%m/%d/%y")
    end_date = date_1 + datetime.timedelta(days=dayssince1970[0])

    #    print(end_date)
    #    print(end_date.strftime("%Y%m%d"))

    dateStr = end_date.strftime("%Y%m%d")

    precip = nc.variables[precipVar][:]

    # -- eliminate unnecessary time dimension from precip variable in IMERG
    # dims are lon,lat
    precip = precip.reshape(precip.shape[1], precip.shape[2])

    # globals for precip values and stats by district
    districtPrecip = {}
    districtPrecipStats = {}
    districtPolygons = {}

    #    im = PIL.Image.new(mode="RGB", size=(lon.shape[0], lat.shape[0]), color=(255, 255, 255))

    for district in districts:
        shape = district['geometry']
        coords = district['geometry']['coordinates']
        #       name = district['properties']['name']
        name = district['name']
        dist_id = district['id']

        def handle_subregion(subregion):
            #            poly = Polygon(subregion, edgecolor='k', linewidth=1., zorder=2, label=name)
            poly = Polygon(subregion,
                           edgecolor='k',
                           linewidth=1.,
                           zorder=2,
                           label=dist_id)
            return poly

        distPoly = []

        minlat = 90.0
        maxlat = -90.0
        minlon = 180.0
        maxlon = -180.0
        if shape["type"] == "Polygon":
            for subregion in coords:
                distPoly.append(handle_subregion(subregion))
                for coord in subregion:
                    minlat, minlon, maxlat, maxlon = find_maxmin_latlon(
                        coord[1], coord[0], minlat, minlon, maxlat, maxlon)
        elif shape["type"] == "MultiPolygon":
            for subregion in coords:
                #            print("subregion")
                for sub1 in subregion:
                    #                print("sub-subregion")
                    distPoly.append(handle_subregion(sub1))
                    for coord in sub1:
                        minlat, minlon, maxlat, maxlon = find_maxmin_latlon(
                            coord[1], coord[0], minlat, minlon, maxlat, maxlon)
        else:
            print
            "Skipping", dist_id, \
            "because of unknown type", shape["type"]
        # compute statisics
#        accumPrecipByDistrict(distPoly, precip, lat, lon, districtPrecip,minlat,minlon,maxlat,maxlon,im)
        accumPrecipByDistrict(distPoly, precip, lat, lon, districtPrecip,
                              minlat, minlon, maxlat, maxlon)
        districtPolygons[dist_id] = distPoly

    calcDistrictStats(districtPrecip, districtPrecipStats)
    for district in districts:
        # name = district['properties']['name']
        dist_id = district['id']
        name = district['name']
#        print("district name ", name)
#        print("district id", dist_id)
#        print("mean precip ", districtPrecipStats[dist_id]['mean'])
#        print("median precip ", districtPrecipStats[dist_id]['median'])
#        print("max precip ", districtPrecipStats[dist_id]['max'])
#        print("min precip ", districtPrecipStats[dist_id]['min'])
#        print("count ", districtPrecipStats[dist_id]['count'])

#    print("finished file " + key)
    nc.close()
    # output image
    #    im.save('/tmp/sl_img.jpg', quality=95)
    #    s3.Bucket(s3_bucket).upload_file("/tmp/sl_img.jpg", "test/" + "sl_img.jpg")

    # reformat new json structure
    #    outputJson = {'dataValues' : []}
    outputJson = []
    for key in districtPrecipStats.keys():
        value = districtPrecipStats[key][statType]
        jsonRecord = {
            'dataElement': dataElement,
            'period': dateStr,
            'orgUnit': key,
            'value': value
        }
        outputJson.append(jsonRecord)

    return outputJson
Exemplo n.º 23
0
from mpl_toolkits.basemap import Basemap, cm, shiftgrid, interp
from netCDF4 import Dataset as NetCDFFile
import numpy as N
import matplotlib.pyplot as plt
import glob
import numpy.ma as ma
from scipy.interpolate import griddata
import matplotlib.colors as colors
from statsmodels.stats.weightstats import DescrStatsW
from scipy.stats import ttest_ind
from matplotlib.markers import TICKDOWN
import datetime
from matplotlib.dates import DateFormatter

area = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/gridareahalf_isam.nc',
    'r')
gridarea = area.variables['cell_area'][:, :]
gridlon = area.variables['lon'][:]
gridlat = area.variables['lat'][:]
gridarea, gridlon = shiftgrid(180.5, gridarea, gridlon, start=False)
#print gridlon
nclu = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/plot/globalcrop/data/soybean_AreaYieldProduction.nc',
    'r')
ncvar_maize = nclu.variables['soybeanData'][:]
latnc = nclu.variables['latitude'][:]
znc = nclu.variables['level'][:]
lonnc = nclu.variables['longitude'][:]
timenc = nclu.variables['time'][:]
latnc = N.flipud(latnc)
Exemplo n.º 24
0
def make_images(dpath,
                path,
                dt=datetime(2019, 5, 1, 0, 0, 0),
                interval=31,
                area='OOI',
                clevs=[39., 44., 0.5],
                lat_w=42.5,
                lon_w=-70.3,
                wind=pd.DataFrame(
                    [[datetime.now() - timedelta(1),
                      datetime.now()], [.1, .1], [.1, .1]])):
    '''dpath: the path of dictionary, use to store telemetered data
        path: use to store images
        dt: start time
        interval: how many days we need make 
        dtimes,u,v are wind in m/s
    '''
    with open(dpath, 'rb') as fp:
        telemetered_dict = pickle.load(fp)
    interval = interval * 24
    for j in range(interval):
        #dtime=dt+timedelta(days=j)
        dtime = dt + timedelta(hours=j)
        print(dtime)
        #url=get_doppio_url(dtime)
        url = 'http://tds.marine.rutgers.edu/thredds/dodsC/roms/doppio/2017_da/his/History_Best'
        while True:
            if zl.isConnected(address=url):
                break
            print('check the website is well or internet is connected?')
            time.sleep(5)
        skip = 0
        while True:
            try:
                nc = NetCDFFile(url)
                lons = nc.variables['lon_rho'][:]
                lats = nc.variables['lat_rho'][:]
                temps = nc.variables['temp']
                depth = nc.variables['h'][:]
                time_var = nc['time']
                itime = netCDF4.date2index(dtime, time_var, select='nearest')
                break
            except RuntimeError:
                print(str(url) + ': need reread')
            except OSError:
                if zl.isConnected(address=url):
                    print(str(url) + ': file not exit.')
                    skip = 1
                    break
            except KeyboardInterrupt:
                sys.exit()
        if skip == 1:
            continue

        #m_temp=mean_temp(temps)# here we are taking a daily average
        #m_temp=temps[j,0] # JiM made this change 7/16/2020 since we are looking at hourly not daily images
        m_temp = temps[itime, surf_or_bot]  #-1 for surface?
        #m_temp=temps[np.mod(j,24),0]
        ntime = dtime
        #time_str=ntime.strftime('%Y-%m-%d')
        time_str = ntime.strftime('%Y-%m-%d %H00UTC')
        temp = m_temp * 1.8 + 32
        Year = str(ntime.year)
        Month = str(ntime.month)
        Day = str(ntime.day)
        slons, slats = [], []
        try:
            slons, slats, stemp = [], [], []
            for i in telemetered_dict[Year][Month][Day].index:
                slons.append(telemetered_dict[Year][Month][Day]['lon'].iloc[i])
                slats.append(telemetered_dict[Year][Month][Day]['lat'].iloc[i])
                stemp.append(
                    telemetered_dict[Year][Month][Day]['temp'].iloc[i])
        except:
            slons, slats, stemp = [], [], []
        plotit(lons,
               lats,
               slons,
               slats,
               stemp,
               temp,
               depth,
               time_str,
               path,
               dpi=80,
               area=area,
               clevs=clevs,
               lat_w=lat_w,
               lon_w=lon_w,
               wind=wind)
Exemplo n.º 25
0
        luharea[idx, :] = N.sum(isamarea, axis=(1, 2))

        allproisam[idx, :] = (N.sum(isampmask, axis=(1, 2)))
        allyisam[idx, :] = N.sum(isampmask, axis=(1, 2)) / (N.sum(isamarea,
                                                                  axis=(1, 2)))
        isamgrid[idx, :] = (N.sum(isampmask, axis=(1, 2)) /
                            (N.sum(areak, axis=(1, 2))) * 10000)
    return allproisam, allyisam, isamgrid


nn = 9
year = 86

edat = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/isam/maisoy_cheyenne/rcp45new/equili/maiequilibrium/output/maiequilibrium.nc',
    'r')
eiyield1ynew = edat.variables['totalyield'][:, :, :]

edat2 = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/isam/maisoy_cheyenne/rcp45new/equili/maiequilibrium_irr/output/maiequilibrium_irr.nc',
    'r')
eiyield2ynew = edat2.variables['totalyield'][:, :, :]

edat3 = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/isam/maisoy_cheyenne/rcp45new/equili/maiequilibrium_fert/output/maiequilibrium_fert.nc',
    'r')
eiyield3ynew = edat3.variables['totalyield'][:, :, :]

edat4 = NetCDFFile(
    '/scratch2/scratchdirs/tslin2/isam/maisoy_cheyenne/rcp45new/equili/maiequilibrium_co2/output/maiequilibrium_co2.nc',
Exemplo n.º 26
0
    # we will build the mesh from scratch
    shutil.copyfile('../setup_mesh/landice_grid.nc', filename)
else:
    # use the final state of experiment A
    try:
        stat = os.system('ncks -O -d Time,-1 ../experiment_A/output.nc ./' +
                         filename)
        if stat != 0:
            raise error('ncks error')
    except:
        sys.exit(
            "Error: problem building initial condition file from final state of Experiment A.  Make sure Experiment A has completed successfully before running tests B, C, or D."
        )

# Open the new input file, get needed dimensions & variables
gridfile = NetCDFFile(filename, 'r+')
nVertLevels = len(gridfile.dimensions['nVertLevels'])
# Get variables
xCell = gridfile.variables['xCell'][:]
yCell = gridfile.variables['yCell'][:]
xEdge = gridfile.variables['xEdge'][:]
yEdge = gridfile.variables['yEdge'][:]
xVertex = gridfile.variables['xVertex'][:]
yVertex = gridfile.variables['yVertex'][:]

# ===================
# initial conditions
# ===================
# If starting from scratch, setup dimension variables and initial condition variables
if experiment in ('a', 'f', 'g'):
    # Find center of domain
Exemplo n.º 27
0
from mpl_toolkits.basemap import Basemap, cm, shiftgrid,interp,maskoceans
from netCDF4 import Dataset as NetCDFFile
import numpy as N
import matplotlib.pyplot as plt
import numpy.ma as ma
import matplotlib.colors as colors

mask=NetCDFFile('/scratch2/scratchdirs/tslin2/plot/globalcrop/data/Ctry_halfdeg.nc','r')
cou1 = mask.variables['MASK_Country'][:,:]
cou1= ma.masked_where(cou1<=0.0,cou1)

region=NetCDFFile('/project/projectdirs/m1602/datasets4.full/surfdata_05x05.nc','r')
ind = region.variables['REGION_MASK_CRU_NCEP'][:,:]


#area=NetCDFFile('/scratch2/scratchdirs/tslin2/plot/globalcrop/data/gridareahalf.nc','r')
#gridarea = area.variables['cell_area']

isam=NetCDFFile('/scratch2/scratchdirs/tslin2/isam/rice_cheyenne/his_cru/ric_irr_fert/output/ric_irr_fert.nc','r')
lonisam1=isam.variables['lon'][:]
#ric_i_f=isam.variables['totalyield'][96:103,:,:]
#riceb=N.average(ric_i_f,axis=0)


spam=NetCDFFile('/scratch2/scratchdirs/tslin2/plot/globalcrop/data/spammaize_isam.nc','r')
spamy=spam.variables['maiy_total'][:,:]
spampro=spam.variables['maip_total'][:,:]
spamarea=spam.variables['maia_total'][:,:]


#riceb,lona11=shiftgrid(180.5,riceb,lonisam1,start=False)
Exemplo n.º 28
0
from mpl_toolkits.basemap import Basemap
import matplotlib.pyplot as plt
import numpy as np
from numpy import ma
from netCDF4 import Dataset as NetCDFFile
# read in orography of icosahedral global grid.
f = NetCDFFile('C02562.orog.nc')
lons = (180. / np.pi) * f.variables['grid_center_lon'][:]
lats = (180. / np.pi) * f.variables['grid_center_lat'][:]
z = f.variables['zs'][:]
map = Basemap(projection='ortho', lon_0=-105, lat_0=40)
x, y = map(lons, lats)
map.drawcoastlines()
map.drawmapboundary()
# tri=True forwards to axes.tripcolor
#z = ma.masked_where(z < 1.e-5, z) # for testing masked arrays.
map.pcolor(x,
           y,
           z,
           tri=True,
           shading='flat',
           edgecolors='k',
           cmap=plt.cm.hot_r,
           vmin=0,
           vmax=3000)
#map.contourf(x,y,z,np.arange(0,3000,150),tri=True)
#map.contour(x,y,z,np.arange(0,3000,150),tri=True)
plt.title('pcolor plot on a global icosahedral mesh')
plt.show()
def temp_min_max(model_name,
                 dt=datetime(2019, 5, 1, 0, 0, 0),
                 interval=31,
                 area='OOI'):
    ''' 
        Loop through each day to find min/max temp
        model_name:name of model
        dt: start time
        interval: how many days we need make
        area:limited area you want look
    '''
    temp_list = []  #store temperature of min and max
    #if model_name == 'DOPPIO':
    if model_name == 'DOPPIO' or 'GOMOFS':
        interval = interval * 24
        for j in range(interval):
            #dtime=dt+timedelta(days=j)
            dt = local2utc(dt)  #change local time to UTC time
            dtime = dt + timedelta(hours=j)
            #print(dtime)
            url = get_doppio_url(dtime)
            while True:
                if zl.isConnected(address=url):
                    break
                print('check the website is well or internet is connected?')
                time.sleep(5)
            skip = 0
            while True:
                try:
                    nc = NetCDFFile(url)
                    lons = nc.variables['lon_rho'][:]
                    lats = nc.variables['lat_rho'][:]
                    temps = nc.variables['temp']
                    i0, i1, j0, j1 = get_limited_gbox(area, lon=lons, lat=lats)
                    break
                except RuntimeError:
                    print(str(url) + ': need reread')
                except OSError:
                    if zl.isConnected(address=url):
                        print(str(url) + ': file does not exist.')
                        #print('MING CHAO TEST ')
                        skip = 1
                        break
                except KeyboardInterrupt:
                    sys.exit()
            if skip == 1:
                continue
            #m_temp=mean_temp(temps)# here we are taking a daily average
            m_temp = temps[np.mod(j, 24),
                           0]  #0 is bottom of depth,-1 is surface of depth
            #ntime=dtime
            #time_str=ntime.strftime('%Y-%m-%d')
            temp = m_temp * 1.8 + 32
            temp_F = temp[j0:j1, i0:i1]
            Min_temp = int(min(temp_F.data[~np.isnan(temp_F.data)]))
            Max_temp = int(max(temp_F.data[~np.isnan(temp_F.data)]))
            temp_list.append(Min_temp)
            temp_list.append(Max_temp)
    Min_temp = min(temp_list)
    Max_temp = max(
        temp_list
    ) + 3.0  #Gomofs is more warmer than Doppio,so use Doppio's max temperature plus 3 equal Gomofs' max temperature
    return Min_temp, Max_temp
Exemplo n.º 30
0
def make_plot(filename, grid_name, x_name='x', y_name='y', t_name='time',
                n_cols=6, outpath='', filename_prefix='LMA', 
                do_save=True, image_type='pdf', colormap='gist_earth'):
    """ colormap: a string giving the name of a matplotlib built-in colormap, 
            or a matplotlib.colors.Colormap instance
        """

    f = NetCDFFile(filename)
    data = f.variables  # dictionary of variable names to nc_var objects
    dims = f.dimensions # dictionary of dimension names to sizes
    x = data[x_name]
    y = data[y_name]
    t = data[t_name]
    grid = data[grid_name]
    
    assert len(x.shape) == 1
    assert len(y.shape) == 1
    assert len(t.shape) == 1
        
    grid_dims = grid.dimensions # tuple of dimension names
    name_to_idx = dict((k, i) for i, k in enumerate(grid_dims))
    
    grid_t_idx = name_to_idx[t.dimensions[0]]
    grid_x_idx = name_to_idx[x.dimensions[0]]
    grid_y_idx = name_to_idx[y.dimensions[0]]
        
    n_frames = t.shape[0]
    # n_cols = 6
    n_rows = int(ceil( float(n_frames) / n_cols ))
    
    if type(colormap) == type(''):
        colormap = get_cmap(colormap)
    grey_color = (0.5,)*3
    frame_color = (0.2,)*3
    
    density_maxes = []
    total_counts = []
    all_t = []
    
    xedge = centers_to_edges(x)
    x_range = xedge.max() - xedge.min()
    yedge = centers_to_edges(y)
    y_range = yedge.max() - yedge.min()
    dx = (xedge[1]-xedge[0])
    
    # w, h = figaspect(float(n_rows)/n_cols) # breaks for large numbers of frames - has a hard-coded max figure size
    w, h, n_rows_perpage, n_pages = multiples_figaspect(n_rows, n_cols, x_range, y_range, fig_width=8.5, max_height=None)
    
    # count_scale_factor = dx # / 1000.0
    # max_count_baseline = 450 * count_scale_factor #/ 10.0
    min_count, max_count = 1, grid[:].max() #max_count_baseline*(t[1]-t[0])
    if (max_count == 0) | (max_count == 1 ):
        max_count = min_count+1

    default_vmin = -1.0#0.2
    if np.log10(max_count) <= default_vmin:
        vmin_count = np.log10(max_count) + default_vmin
    else:
        vmin_count = default_vmin
    
    fig = Figure(figsize=(w,h))
    canvas = FigureCanvasAgg(fig)
    fig.set_canvas(canvas)
    p = small_multiples_plot(fig=fig, rows=n_rows, columns=n_cols)
    p.label_edges(True)
    pad = 0.0 # for time labels in each frame
    
    for ax in p.multiples.flat:
        if int(matplotlib.__version__[0]) <= 1:
            ax.set_axis_bgcolor('black')
        else:
            ax.set_facecolor('black')
        ax.spines['top'].set_edgecolor(frame_color)
        ax.spines['bottom'].set_edgecolor(frame_color)
        ax.spines['left'].set_edgecolor(frame_color)
        ax.spines['right'].set_edgecolor(frame_color)
    #     ax.yaxis.set_major_formatter(kilo_formatter)
    #     ax.xaxis.set_major_formatter(kilo_formatter)
    base_date = datetime.strptime(t.units, "seconds since %Y-%m-%d %H:%M:%S")
    time_delta = timedelta(0,float(t[0]),0)
    start_time = base_date + time_delta
        
    indexer = [slice(None),]*len(grid.shape)
    
    
    frame_start_times = []
    for i in range(n_frames):
        frame_start = base_date + timedelta(0,float(t[i]),0)
        frame_start_times.append(frame_start)
        indexer[grid_t_idx] = i
        
        density = grid[indexer]
        
        # density,edges = np.histogramdd((x,y), bins=(xedge,yedge))
        density_plot  = p.multiples.flat[i].pcolormesh(xedge,yedge,
                                   np.log10(density.transpose()), 
                                   vmin=vmin_count,
                                   vmax=np.log10(max_count),
                                   cmap=colormap)
        label_string = frame_start.strftime('%H%M:%S')
        text_label = p.multiples.flat[i].text(xedge[0]-pad+x_range*.015, yedge[0]-pad+y_range*.015, label_string, color=grey_color, size=6)
        density_plot.set_rasterized(True)
        density_maxes.append(density.max())
        total_counts.append(density.sum())
        all_t.append(frame_start)
        print(label_string, x.shape, density.max(), density.sum())
        
    color_scale = ColorbarBase(p.colorbar_ax, cmap=density_plot.cmap,
                                       norm=density_plot.norm,
                                       orientation='horizontal')
    
    # color_scale.set_label('count per pixel')
    color_scale.set_label('log10(count per pixel)')
    
    view_x = (xedge.min(), xedge.max())
    view_y = (yedge.min(), yedge.max())
    
    print('making multiples', end=' ')
    p.multiples.flat[0].axis(view_x+view_y)
    filename = '%s-%s_%s_%05.2fkm_%05.1fs.%s' % (filename_prefix, grid_name, start_time.strftime('%Y%m%d_%H%M%S'), dx, time_delta.seconds, image_type)
    filename = os.path.join(outpath, filename)
    if do_save:
        fig.savefig(filename, dpi=150)
    
    return fig, p, frame_start_times, filename
    
    print(' ... done')