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()
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
# 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,
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.)
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, :, :]
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.)
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.)
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',
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)][:, :]
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
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'][:]
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']
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
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]
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
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)
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',
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')
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, :, :]
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.")
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
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)
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)
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',
# 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
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)
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
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')
