def plotWeightChanges():
if f.usestdp:
# create plot
figh = figure(figsize=(1.2*8,1.2*6))
figh.subplots_adjust(left=0.02) # Less space on left
figh.subplots_adjust(right=0.98) # Less space on right
figh.subplots_adjust(top=0.96) # Less space on bottom
figh.subplots_adjust(bottom=0.02) # Less space on bottom
figh.subplots_adjust(wspace=0) # More space between
figh.subplots_adjust(hspace=0) # More space between
h = axes()
# create data matrix
wcs = [x[-1][-1] for x in f.allweightchanges] # absolute final weight
wcs = [x[-1][-1]-x[0][-1] for x in f.allweightchanges] # absolute weight change
pre,post,recep = zip(*[(x[0],x[1],x[2]) for x in f.allstdpconndata])
ncells = int(max(max(pre),max(post))+1)
wcmat = zeros([ncells, ncells])
for iwc,ipre,ipost,irecep in zip(wcs,pre,post,recep):
wcmat[int(ipre),int(ipost)] = iwc *(-1 if irecep>=2 else 1)
# plot
imshow(wcmat,interpolation='nearest',cmap=bicolormap(gap=0,mingreen=0.2,redbluemix=0.1,epsilon=0.01))
xlabel('post-synaptic cell id')
ylabel('pre-synaptic cell id')
h.set_xticks(f.popGidStart)
h.set_yticks(f.popGidStart)
h.set_xticklabels(f.popnames)
h.set_yticklabels(f.popnames)
h.xaxif.set_ticks_position('top')
xlim(-0.5,ncells-0.5)
ylim(ncells-0.5,-0.5)
clim(-abs(wcmat).max(),abs(wcmat).max())
colorbar()
def plot_field(self,x,y,u=None,v=None,F=None,contour=False,outdir=None,plot='quiver',figname='_field',format='eps'):
outdir = self.set_dir(outdir)
p = 64
if F is None: F=self.calc_F(u,v)
plt.close('all')
plt.figure()
#fig, axes = plt.subplots(nrows=1)
if contour:
plt.hold(True)
plt.contourf(x,y,F)
if plot=='quiver':
plt.quiver(x[::p],y[::p],u[::p],v[::p],scale=0.1)
if plot=='pcolor':
plt.pcolormesh(x[::4],y[::4],F[::4],cmap=plt.cm.Pastel1)
plt.colorbar()
if plot=='stream':
speed = F[::16]
plt.streamplot(x[::16], y[::16], u[::16], v[::16], density=(1,1),color='k')
plt.xlabel('$x$ (a.u.)')
plt.ylabel('$y$ (a.u.)')
plt.savefig(os.path.join(outdir,figname+'.'+format),format=format,dpi=320,bbox_inches='tight')
plt.close()
def plot_confusion_matrix(cm, title='', cmap=plt.cm.Blues):
#print cm
#display vehicle, idle, walking accuracy respectively
#display overall accuracy
print type(cm)
# plt.figure(index
plt.imshow(cm, interpolation='nearest', cmap=cmap)
#plt.figure("")
plt.title("Confusion Matrix")
plt.colorbar()
tick_marks = [0,1,2]
target_name = ["driving","idling","walking"]
plt.xticks(tick_marks,target_name,rotation=45)
plt.yticks(tick_marks,target_name,rotation=45)
print len(cm[0])
for i in range(0,3):
for j in range(0,3):
plt.text(i,j,str(cm[i,j]))
plt.tight_layout()
plt.ylabel("Actual Value")
plt.xlabel("Predicted Outcome")
def plot(self, normalized=False, backend=None, ax=None, **kwargs):
"""
Plots confusion matrix
"""
df = self.to_dataframe(normalized)
try:
cmap = kwargs['cmap']
except:
cmap = plt.cm.gray_r
title = self.title
if normalized:
title += " (normalized)"
if backend is None:
backend = self.backend
if backend == Backend.Matplotlib:
#if ax is None:
fig, ax = plt.subplots(figsize=(9, 8))
plt.imshow(df, cmap=cmap, interpolation='nearest') # imshow / matshow
ax.set_title(title)
tick_marks_col = np.arange(len(df.columns))
tick_marks_idx = tick_marks_col.copy()
ax.set_yticks(tick_marks_idx)
ax.set_xticks(tick_marks_col)
ax.set_xticklabels(df.columns, rotation=45, ha='right')
ax.set_yticklabels(df.index)
ax.set_ylabel(df.index.name)
ax.set_xlabel(df.columns.name)
(N_min, N_max) = (0, self.max())
if N_max > COLORBAR_TRIG:
plt.colorbar() # Continuous colorbar
else:
# Discrete colorbar
ax2 = fig.add_axes([0.93, 0.1, 0.03, 0.8])
bounds = np.arange(N_min, N_max + 2, 1)
norm = mpl.colors.BoundaryNorm(bounds, cmap.N)
cb = mpl.colorbar.ColorbarBase(ax2, cmap=cmap, norm=norm, spacing='proportional', ticks=bounds, boundaries=bounds, format='%1i')
return(ax)
elif backend == Backend.Seaborn:
import seaborn as sns
ax = sns.heatmap(df, **kwargs)
return(ax)
# You should test this yourself
# because I'm facing an issue with Seaborn under Mac OS X (2015-04-26)
# RuntimeError: Cannot get window extent w/o renderer
#sns.plt.show()
else:
raise(NotImplementedError("backend=%r not allowed" % backend))
def plot_bernoulli_matrix(self, show_npfs=False):
"""
Plot the heatmap of the Bernoulli matrix
@self
@show_npfs - Highlight NPFS detections [Boolean]
"""
matrix = self.Bernoulli_matrix
if show_npfs == False:
plot = plt.imshow(matrix)
plot.set_cmap('hot')
plt.colorbar()
plt.xlabel("Bootstraps")
plt.ylabel("Feature")
plt.show()
else:
for i in self.selected_features:
for k in range(len(matrix[i])):
matrix[i,k] = .5
plot = plt.imshow(matrix)
plot.set_cmap('hot')
plt.xlabel("Bootstraps")
plt.ylabel("Feature")
plt.colorbar()
plt.show()
return None
def test_likelihood_evaluator3():
tr = template.TemplateRenderCircleBorder()
tr.set_params(14, 6, 4)
t1 = tr.render(0, np.pi/2)
img = np.zeros((240, 320), dtype=np.uint8)
env = util.Environmentz((1.5, 2.0), (240, 320))
le2 = likelihood.LikelihoodEvaluator3(env, tr)
img[(120-t1.shape[0]/2):(120+t1.shape[0]/2),
(160-t1.shape[1]/2):(160+t1.shape[1]/2)] += t1 *255
pylab.subplot(1, 2, 1)
pylab.imshow(img, interpolation='nearest', cmap=pylab.cm.gray)
state = np.zeros(1, dtype=util.DTYPE_STATE)
xvals = np.linspace(0, 2., 100)
yvals = np.linspace(0, 1.5, 100)
res = np.zeros((len(yvals), len(xvals)), dtype=np.float32)
for yi, y in enumerate(yvals):
for xi, x in enumerate(xvals):
state[0]['x'] = x
state[0]['y'] = y
state[0]['theta'] = np.pi / 2.
res[yi, xi] = le2.score_state(state, img)
pylab.subplot(1, 2, 2)
pylab.imshow(res)
pylab.colorbar()
pylab.show()
def plot_grid_experiment_results(grid_results, params, metrics):
global plt
params = sorted(params)
grid_params = grid_results.grid_params
plt.figure(figsize=(8, 6))
for metric in metrics:
grid_params_shape = [len(grid_params[k]) for k in sorted(grid_params.keys())]
params_max_out = [(1 if k in params else 0) for k in sorted(grid_params.keys())]
results = np.array([e.results.get(metric, 0) for e in grid_results.experiments])
results = results.reshape(*grid_params_shape)
for axis, included_in_params in enumerate(params_max_out):
if not included_in_params:
results = np.apply_along_axis(np.max, axis, results)
print results
params_shape = [len(grid_params[k]) for k in sorted(params)]
results = results.reshape(*params_shape)
if len(results.shape) == 1:
results = results.reshape(-1,1)
import matplotlib.pylab as plt
#f.subplots_adjust(left=.2, right=0.95, bottom=0.15, top=0.95)
plt.imshow(results, interpolation='nearest', cmap=plt.cm.hot)
plt.title(str(grid_results.name) + " " + metric)
if len(params) == 2:
plt.xticks(np.arange(len(grid_params[params[1]])), grid_params[params[1]], rotation=45)
plt.yticks(np.arange(len(grid_params[params[0]])), grid_params[params[0]])
plt.colorbar()
plt.show()
def plotMatrix(data):
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.set_aspect('equal')
plt.imshow(data, interpolation='nearest', cmap=plt.cm.ocean)
plt.colorbar()
plt.show()
def XXtest5_regrid(self):
srcF = cdms2.open(sys.prefix + \
'/sample_data/so_Omon_ACCESS1-0_historical_r1i1p1_185001-185412_2timesteps.nc')
so = srcF('so')[0, 0, ...]
clt = cdms2.open(sys.prefix + '/sample_data/clt.nc')('clt')
dstData = so.regrid(clt.getGrid(),
regridTool = 'esmf',
regridMethod='conserve')
if self.pe == 0:
dstDataMask = (dstData == so.missing_value)
dstDataFltd = dstData * (1 - dstDataMask)
zeroValCnt = (dstData == 0).sum()
if so.missing_value > 0:
dstDataMin = dstData.min()
dstDataMax = dstDataFltd.max()
else:
dstDataMin = dstDataFltd.min()
dstDataMax = dstData.max()
zeroValCnt = (dstData == 0).sum()
print 'Number of zero valued cells', zeroValCnt
print 'min/max value of dstData: %f %f' % (dstDataMin, dstDataMax)
self.assertLess(dstDataMax, so.max())
if False:
pylab.figure(1)
pylab.pcolor(so, vmin=20, vmax=40)
pylab.colorbar()
pylab.title('so')
pylab.figure(2)
pylab.pcolor(dstData, vmin=20, vmax=40)
pylab.colorbar()
pylab.title('dstData')
def test2_varRegrid(self):
print
print 'test2_varRegrid'
srcF = cdms2.open(sys.prefix + \
'/sample_data/so_Omon_ACCESS1-0_historical_r1i1p1_185001-185412_2timesteps.nc')
so = srcF('so')[0, 0, ...]
clt = cdms2.open(sys.prefix + '/sample_data/clt.nc')('clt')
diag = {'srcAreas': None, 'dstAreas': None,
'srcAreaFractions': None, 'dstAreaFractions': None}
soInterp = so.regrid(clt.getGrid(),
regridTool = 'esmf',
regridMethod='conserve',
diag = diag)
if self.pe == 0:
totSrcArea = diag['srcAreas'].sum()
totDstArea = diag['dstAreas'].sum()
totSrcFrac = diag['srcAreaFractions'].sum()
self.assertEqual(numpy.isnan(totSrcFrac).sum(), 0)
self.assertLess(abs(totSrcArea - 4*pi)/(4*pi), 0.02)
self.assertLess(abs(totDstArea - 4*pi)/(4*pi), 0.01)
soMass = (so*diag['srcAreas']).sum()
inMass = (soInterp*diag['dstAreas']).sum()
print soMass, inMass
diff = abs(soMass - inMass)/soMass
self.assertLess(diff, 7.e-7)
if False:
pylab.subplot(1, 2, 1)
pylab.pcolor(so, vmin = 20, vmax = 40)
pylab.colorbar()
pylab.title('so')
pylab.subplot(1, 2, 2)
pylab.pcolor(soInterp, vmin = 20, vmax = 40)
pylab.colorbar()
pylab.title('soInterp')
def plotscalefactors(self):
'''
Plots the distribution of scalefactors between consecutive images.
This is to check manually that the hdr image assembly is done correctly.
'''
import matplotlib.pylab as plt
print('Scalefactors for HDR-assembling are', self.scalefactors)
print('Standard deviations for Scalefactors are', self.scalefactorsstd)
# Plots the scalefactordistribution and scalefactors for each pixelvalue
self.scaleforpix = range(len(self.raw))
for n in range(len(self.raw) - 1):
A = self.getimgquotient(n)
B = self._getrealimg(n + 1)
fig = plt.figure()
plt.xlabel('x [pixel]')
plt.ylabel('y [pixel]')
fig.set_size_inches(10, 10)
plt.imshow(A)
plt.clim([0.95 * A[np.isfinite(A)].min(), 1.05 * A[np.isfinite(A)].max()])
plt.colorbar()
fig = plt.figure()
linplotdata = np.array([B[np.isfinite(B)].flatten(), A[np.isfinite(B)].flatten()])
plt.plot(linplotdata[0, :], linplotdata[1, :], 'ro')
def plot(x,y,field,filename,c=200):
plt.figure()
# define grid.
xi = np.linspace(min(x),max(x),100)
yi = np.linspace(min(y),max(y),100)
# grid the data.
si_lin = griddata((x, y), field, (xi[None,:], yi[:,None]), method='linear')
si_cub = griddata((x, y), field, (xi[None,:], yi[:,None]), method='linear')
print np.min(field)
print np.max(field)
plt.subplot(211)
# contour the gridded data, plotting dots at the randomly spaced data points.
CS = plt.contour(xi,yi,si_lin,c,linewidths=0.5,colors='k')
CS = plt.contourf(xi,yi,si_lin,c,cmap=plt.cm.jet)
plt.colorbar() # draw colorbar
# plot data points.
# plt.scatter(x,y,marker='o',c='b',s=5)
plt.xlim(min(x),max(x))
plt.ylim(min(y),max(y))
plt.title('Lineaarinen interpolointi')
#plt.tight_layout()
plt.subplot(212)
# contour the gridded data, plotting dots at the randomly spaced data points.
CS = plt.contour(xi,yi,si_cub,c,linewidths=0.5,colors='k')
CS = plt.contourf(xi,yi,si_cub,c,cmap=plt.cm.jet)
plt.colorbar() # draw colorbar
# plot data points.
# plt.scatter(x,y,marker='o',c='b',s=5)
plt.xlim(min(x),max(x))
plt.ylim(min(y),max(y))
plt.title('Kuubinen interpolointi')
plt.savefig(filename)
def test2_3x4_to_5x7_cart(self):
# Test non-periodic grid returning double grid resolution
roESMP = CdmsRegrid(self.fromGrid3x4, self.toGrid5x7,
dtype = self.data3x4.dtype,
srcGridMask = self.data3x4.mask,
regridTool = 'ESMP',
periodicity = 0,
regridMethod = 'Conserve',
coordSys = 'cart')
diag = {'srcAreas':0, 'dstAreas':0,
'srcAreaFractions':0, 'dstAreaFractions':0}
ESMP5x7 = roESMP(self.data3x4, diag = diag)
dstMass = (ESMP5x7 * diag['dstAreas']).sum()
srcMass = (self.data3x4 * diag['srcAreas'] \
* diag['srcAreaFractions']).sum()
if False:
pylab.figure(1)
pylab.pcolor(self.data3x4)
pylab.colorbar()
pylab.title('original self.data3x4')
pylab.figure(2)
pylab.pcolor(ESMP5x7)
pylab.colorbar()
pylab.title('interpolated ESMP5x7')
self.assertLess(abs(srcMass - dstMass), self.eps)
self.assertEqual(self.data3x4[0,0], ESMP5x7[0,0])
self.assertEqual(1.0, ESMP5x7[0,0])
self.assertEqual(0.25, ESMP5x7[1,1])
self.assertEqual(0.0, ESMP5x7[2,2])
def perform_interpolation(self,dataextrap,regridme,field_src,field_target,use_locstream):
data = self.allocate()
if self.geometry == 'surface':
for kz in _np.arange(self.nz):
field_src.data[:] = dataextrap[kz,:,:].transpose()
field_target = regridme(field_src, field_target)
if use_locstream:
if self.nx == 1:
data[kz,:,0] = field_target.data.copy()
elif self.ny == 1:
data[kz,0,:] = field_target.data.copy()
else:
data[kz,:,:] = field_target.data.transpose()[self.jmin:self.jmax+1, \
self.imin:self.imax+1]
if self.debug and kz == 0:
data_target_plt = _np.ma.masked_values(data[kz,:,:],self.xmsg)
#data_target_plt = _np.ma.masked_values(field_target.data,self.xmsg)
_plt.figure() ; _plt.contourf(data_target_plt[:,:],40) ; _plt.colorbar() ;
_plt.title('regridded') ; _plt.show()
elif self.geometry == 'line':
field_src.data[:] = dataextrap[:,:].transpose()
field_target = regridme(field_src, field_target)
if use_locstream:
data[:,:] = _np.reshape(field_target.data.transpose(),(self.ny,self.nx))
else:
data[:,:] = field_target.data.transpose()[self.jmin:self.jmax+1,self.imin:self.imax+1]
return data
def reconstructContactMap(map, datavec):
""" Plots a given vector as a contact map
Parameters
----------
map : np.ndarray 2D
The map from a MetricData object
datavec : np.ndarray
The data we want to plot in a 2D map
"""
map = np.array(map, dtype=int)
atomidx = np.unique(map.flatten()).astype(int)
mask = np.zeros(max(atomidx)+1, dtype=int)
mask[atomidx] = range(len(atomidx))
# Create a new map which maps from vector indexes to matrix indexes
newmap = np.zeros(np.shape(map), dtype=int)
newmap[:, 0] = mask[map[:, 0]]
newmap[:, 1] = mask[map[:, 1]]
contactmap = np.zeros((len(atomidx), len(atomidx)))
for i in range(len(datavec)):
contactmap[newmap[i, 0], newmap[i, 1]] = datavec[i]
contactmap[newmap[i, 1], newmap[i, 0]] = datavec[i]
from matplotlib import pylab as plt
plt.imshow(contactmap, interpolation='nearest', aspect='equal')
plt.colorbar()
#plt.axis('off')
#plt.tick_params(axis='x', which='both', bottom='off', top='off', labelbottom='off')
#plt.tick_params(axis='y', which='both', left='off', right='off', labelleft='off')
plt.show()
def testSingleTimeSingleElev(self):
"""
Interpolate over one level/time
"""
f = cdms2.open(sys.prefix + '/sample_data/clt.nc')
clt = f('clt')
v = f('v')[0,0,...]
srcGrid = v.getGrid()
dstGrid = clt.getGrid()
ro = CdmsRegrid(srcGrid = srcGrid,
dstGrid = dstGrid,
dtype = v.dtype)
vInterp = ro(v)
print 'min/max of v: %f %f' % (v.min(), v.max())
print 'min/max of vInterp: %f %f' % (vInterp.min(), vInterp.max())
if False:
pl.figure()
pl.pcolor(vInterp, vmin=-20, vmax=20)
pl.title('testSingleTimeSingleElev: vInterp')
pl.colorbar()
def drown_field(self,data,mask,drown):
''' drown_field is a wrapper around the fortran code fill_msg_grid.
depending on the output geometry, applies land extrapolation on 1 or N levels'''
if self.geometry == 'surface':
for kz in _np.arange(self.nz):
tmpin = data[kz,:,:].transpose()
if self.debug and kz == 0:
tmpin_plt = _np.ma.masked_values(tmpin,self.xmsg)
_plt.figure() ; _plt.contourf(tmpin_plt.transpose(),40) ; _plt.colorbar() ;
_plt.title('normalized before drown')
if drown == 'ncl':
tmpout = _fill.mod_poisson.poisxy1(tmpin,self.xmsg, self.guess, self.gtype, \
self.nscan, self.epsx, self.relc)
elif drown == 'sosie':
tmpout = _mod_drown_sosie.mod_drown.drown(self.kew,tmpin,mask[kz,:,:].T,\
nb_inc=200,nb_smooth=40)
data[kz,:,:] = tmpout.transpose()
if self.debug and kz == 0:
_plt.figure() ; _plt.contourf(tmpout.transpose(),40) ; _plt.colorbar() ;
_plt.title('normalized after drown')
_plt.show()
elif self.geometry == 'line':
tmpin = data[:,:].transpose()
if drown == 'ncl':
tmpout = _fill.mod_poisson.poisxy1(tmpin,self.xmsg, self.guess, self.gtype, \
self.nscan, self.epsx, self.relc)
elif drown == 'sosie':
tmpout = _mod_drown_sosie.mod_drown.drown(self.kew,tmpin,mask[:,:].T,\
nb_inc=200,nb_smooth=40)
data[:,:] = tmpout.transpose()
return data
def __init__ (self, im, location, fprefix='./', wrpng=1, pltmoon=0):
self._wrpng = wrpng;
self._im = im;
self._fprefix = fprefix;
self._pltmoon = pltmoon;
self._loc = location;
# Available locations
if self._loc.lower() == 'lofar':
self._obssite = ephem.Observer();
self._obssite.pressure = 0; # To prevent refraction corrections.
self._obssite.lon, self._obssite.lat = '6.869837540','52.915122495'; # CS002 on LOFAR
elif self._loc.lower() == 'dwingeloo':
self._obssite = ephem.Observer();
self._obssite.pressure = 0; # To prevent refraction corrections.
self._obssite.lon, self._obssite.lat = '6.396297','52.812204'; # Dwingeloo telescope
else:
print 'Unknown observatory site!'
if self._pltmoon == 1:
self._moon = ephem.Moon();
self._casa = ephem.readdb('Cas-A,f|J, 23:23:26.0, 58:48:00,99.00,2000');
if matplotFound ==0 & ephemFound == 0:
print 'Matplotlib or pyephem not found! PNG Images written to disk.'
self._wrpng = 1;
else:
self._imgplt = plt.imshow (abs(self._im._skymap[:,:]), extent = [self._im._l[0], self._im._l[-1], self._im._m[0], self._im._m[-1]]);
plt.colorbar();
def generate_matrix_visualization(known_words, bookmark_words):
m = []
for i in range(0,100):
m.append([])
for j in range (0, 100):
if (i*100+j) in bookmark_words:
m[i].append(0.65)
elif (i*100+j) in known_words:
m[i].append(0.4)
else:
m[i].append(0.2)
m.reverse()
# we need this next line to scale the color scheme
m[0][0]=0
matrix = numpy.matrix(m)
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.set_aspect('equal')
plt.imshow(matrix, interpolation='none', extent=[0,10000,0,10000])
frame = pylab.gca()
frame.axes.get_xaxis().set_ticks([])
#plt.axis([0,10000,0,10000])
plt.ylabel('Rank')
plt.title('Encountered Ranked Words by User')
plt.colorbar()
plt.show()
def generate_matrix_visualization(known_words, bookmark_words):
m = []
for i in range(0,100):
m.append([])
for j in range (0, 100):
if (i*100+j) in bookmark_words:
m[i].append(0.65)
elif (i*100+j) in known_words:
m[i].append(0.4)
else:
m[i].append(0.2)
m.reverse()
# we need this next line to scale the color scheme
m[0][0]=0
matrix = numpy.matrix(m)
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.set_aspect('equal')
plt.imshow(matrix, interpolation='none')
plt.set_cmap('hot')
plt.colorbar()
plt.show()
def showladderpca(self):
import mdp
from matplotlib import pylab as plt
import pprint
import math
cerr('calculating PCA & plotting')
peak_sizes = sorted(list([ x.rtime for x in self.alleles ]))
#peak_sizes = sorted( peak_sizes )[:-5]
#pprint.pprint(peak_sizes)
#comps = algo.simple_pca( peak_sizes )
#algo.plot_pca(comps, peak_sizes)
from fatools.lib import const
std_sizes = const.ladders['LIZ600']['sizes']
x = std_sizes
y = [ x * 0.1 for x in peak_sizes ]
D = np.zeros( (len(y), len(x)) )
for i in range(len(y)):
for j in range(len(x)):
D[i,j] = math.exp( ((x[j] - y[i]) * 0.001) ** 2 )
pprint.pprint(D)
im = plt.imshow(D, interpolation='nearest', cmap='Reds')
plt.gca().invert_yaxis()
plt.xlabel("STD")
plt.ylabel("PEAK")
plt.grid()
plt.colorbar()
plt.show()
def plot_prof(obj):
'''Function that plots a vertical profile of scattering from
TOC to BOC.
Input: rt_layer instance object.
Output: plot of scattering.
'''
I = obj.Inodes[:,1,:] \
/ -obj.mu_s
y = np.linspace(obj.Lc, 0., obj.K+1)
x = obj.views*180./np.pi
xm = np.array([])
for i in np.arange(0,len(x)-1):
nx = x[i] + (x[i+1]-x[i])/2.
xm = np.append(xm,nx)
xm = np.insert(xm,0,0.)
xm = np.append(xm,180.)
xx, yy = np.meshgrid(xm, y)
plt.pcolormesh(xx,yy,I)
plt.colorbar()
plt.title('Canopy Fluxes')
plt.xlabel('Exit Zenith Angle')
plt.ylabel('Cumulative LAI (0=soil)')
plt.arrow(135.,3.5,0.,-3.,head_width=5.,head_length=.2,\
fc='k',ec='k')
plt.text(140.,2.5,'Downwelling Flux',rotation=90)
plt.arrow(45.,.5,0.,3.,head_width=5.,head_length=.2,\
fc='k',ec='k')
plt.text(35.,2.5,'Upwelling Flux',rotation=270)
plt.show()
def plot_image(*positional_parameters,title="TITLE",xtitle=r"X",ytitle=r"Y",cmap=None,aspect=None,show=1):
n_arguments = len(positional_parameters)
if n_arguments == 1:
z = positional_parameters[0]
x = np.arange(0,z.shape[0])
y = np.arange(0,z.shape[0])
elif n_arguments == 2:
z = positional_parameters[0]
x = positional_parameters[1]
y = positional_parameters[1]
elif n_arguments == 3:
z = positional_parameters[0]
x = positional_parameters[1]
y = positional_parameters[2]
else:
raise Exception("Bad number of inputs")
fig = plt.figure()
# cmap = plt.cm.Greys
plt.imshow(z.T,origin='lower',extent=[x[0],x[-1],y[0],y[-1]],cmap=cmap,aspect=aspect)
plt.colorbar()
ax = fig.gca()
ax.set_xlabel(xtitle)
ax.set_ylabel(ytitle)
plt.title(title)
if show:
plt.show()
return fig
def plotConn():
# Create plot
figh = figure(figsize=(8,6))
figh.subplots_adjust(left=0.02) # Less space on left
figh.subplots_adjust(right=0.98) # Less space on right
figh.subplots_adjust(top=0.96) # Less space on bottom
figh.subplots_adjust(bottom=0.02) # Less space on bottom
figh.subplots_adjust(wspace=0) # More space between
figh.subplots_adjust(hspace=0) # More space between
h = axes()
totalconns = zeros(shape(f.connprobs))
for c1 in range(size(f.connprobs,0)):
for c2 in range(size(f.connprobs,1)):
for w in range(f.nreceptors):
totalconns[c1,c2] += f.connprobs[c1,c2]*f.connweights[c1,c2,w]*(-1 if w>=2 else 1)
imshow(totalconns,interpolation='nearest',cmap=bicolormap(gap=0))
# Plot grid lines
hold(True)
for pop in range(f.npops):
plot(array([0,f.npops])-0.5,array([pop,pop])-0.5,'-',c=(0.7,0.7,0.7))
plot(array([pop,pop])-0.5,array([0,f.npops])-0.5,'-',c=(0.7,0.7,0.7))
# Make pretty
h.set_xticks(range(f.npops))
h.set_yticks(range(f.npops))
h.set_xticklabels(f.popnames)
h.set_yticklabels(f.popnames)
h.xaxis.set_ticks_position('top')
xlim(-0.5,f.npops-0.5)
ylim(f.npops-0.5,-0.5)
clim(-abs(totalconns).max(),abs(totalconns).max())
colorbar()
def plot_block( files, m, n ):
"""
- files is directory for cell
- m starting index, n ending index
Use pylab.imshow() to plot a frame (npy array).
Note: The boundary should be removed, thus there will not be a halo
"""
#Get all frames
if os.path.isdir (files):
fdir = files + '/'
dlist = os.listdir(fdir)
frames = []
for f in dlist:
if f.endswith('npy') and not os.path.isdir(fdir+f):
frames.append(f)
else:
print 'Error - input is not a directory'
return
#Sort frames
frames . sort(key=natural_key)
stack = []
#load npy arrays
for ind in xrange(len(frames)):
if ind >= m and ind <= n:
stack.append(numpy.load(files + frames[ind]))
#Create 3d array
d = numpy.dstack(stack)
d = numpy.rollaxis(d,-1)
fig = plt.figure()
plt.title("RBC Stack")
plt.imshow(d[1])
plt.colorbar()
plt.show()
def validate(X_test, y_test, pipe, title, fileName):
print('Test Accuracy: %.3f' % pipe.score(X_test, y_test))
y_predict = pipe.predict(X_test)
confusion_matrix = np.zeros((9,9))
for p,r in zip(y_predict, y_test):
confusion_matrix[p-1,r-1] = confusion_matrix[p-1,r-1] + 1
print (confusion_matrix)
confusion_normalized = confusion_matrix.astype('float') / confusion_matrix.sum(axis=1)[:, np.newaxis]
print (confusion_normalized)
pylab.clf()
pylab.matshow(confusion_normalized, fignum=False, cmap='Blues', vmin=0.0, vmax=1.0)
ax = pylab.axes()
ax.set_xticks(range(len(families)))
ax.set_xticklabels(families, fontsize=4)
ax.xaxis.set_label_position('top')
ax.xaxis.set_ticks_position("top")
ax.set_yticks(range(len(families)))
ax.set_yticklabels(families, fontsize=4)
pylab.title(title)
pylab.colorbar()
pylab.grid(False)
pylab.grid(False)
pylab.savefig(fileName, dpi=900)
def plot(rho, u, uLB, tau, rho_history, zdjecia, image, nx, maxIter ):
# plt.figure(figsize=(15,15))
# plt.subplot(4, 1, 1)
# plt.imshow(u[1,:,0:50],vmin=-uLB*.15, vmax=uLB*.15, interpolation='none')#,cmap=cm.seismic
# plt.colorbar()
plt.rcParams["figure.figsize"] = (15,15)
plt.subplot(5, 1, 1)
plt.imshow(sqrt(u[0]**2+u[1]**2),vmin=0, vmax=uLB*1.6)#,cmap=cm.seismic
plt.colorbar()
plt.title('tau = {:f}'.format(tau))
plt.subplot(5, 1, 2)
plt.imshow(u[0,:,:30], interpolation='none')#,cmap=cm.seismicvmax=uLB*1.6,
plt.colorbar()
plt.title('tau = {:f}'.format(tau))
plt.subplot(5, 1, 3)
plt.imshow(rho, interpolation='none' )#,cmap=cm.seismic
plt.title('rho')
plt.subplot(5, 1,4)
plt.title(' history rho')
plt.plot(linspace(0,len(rho_history),len(rho_history)),rho_history)
plt.xlim([0,maxIter])
plt.subplot(5, 1,5)
plt.title(' u0 middle develop')
plt.plot(linspace(0,nx,len(u[0,20,:])), u[1,20,:])
plt.tight_layout()
plt.savefig(path.join(zdjecia,'f{0:06d}.png'.format(image)))
plt.clf();
def show_slice(data, slice_no=0, clim=None):
""" Visualize the reconstructed slice.
Parameters
-----------
data : ndarray
3-D matrix of stacked reconstructed slices.
slice_no : scalar, optional
The index of the slice to be imaged.
"""
plt.figure(figsize=(7, 7))
if len(data.shape) is 2:
plt.imshow(data,
interpolation='none',
cmap='gray')
plt.colorbar()
elif len(data.shape) is 3:
plt.imshow(data[slice_no, :, :],
interpolation='none',
cmap='gray')
plt.colorbar()
if clim is not None:
plt.clim(clim)
plt.show()
def plot(coefs_files, digit=0, mixture=0, axis=0):
import numpy as np
import matplotlib.pylab as plt
import amitgroup as ag
for coefs_file in coefs_files:
coefs_data = np.load(coefs_file)
var = coefs_data['prior_var']
samples = coefs_data['samples']
llh_var = coefs_data['llh_var']
var_flat = ag.util.wavelet.smart_flatten(var[digit,mixture,axis])
last_i = len(var_flat)-1
plt.xlim((0, last_i))
#imdef = ag.util.DisplacementFieldWavelet((32, 32), 'db4', penalty=100
if len(coefs_files) == 1:
add = ""
else:
add = " ({0})".format(coefs_file.name)
plt.subplot(121)
plt.semilogy(1/var_flat, label="ML"+add)
plt.legend(loc=0)
plt.xlabel('Coefficient')
plt.ylabel('Precision $\lambda$')
plt.xlim((0, 63))
plt.subplot(122)
plt.imshow(1/llh_var[digit,mixture], interpolation='nearest')
plt.xlabel("Likelihood precision $\lambda'$")
plt.colorbar()
plt.show()
def save_results(self, file_path_pattern):
"""file_path_pattern could be a dir or a pattern
if it is a dir then /path/to/dir/file1.txt is saved
if it is a pattern then /path/to/pattern-file1.txt is saved"""
fname = file_path_pattern+'p_values.txt'
np.savetxt(fname, self._pvalues)
fname = file_path_pattern+'p_values.png'
pl.figure()
pl.imshow(self._pvalues, interpolation='nearest')
pl.colorbar()
pl.savefig(fname)
fname = file_path_pattern+'values.txt'
np.savetxt(fname, self._measure)
fname = file_path_pattern+'values.png'
pl.figure()
pl.imshow(self._measure, interpolation='nearest', vmax=1, vmin=-1)
pl.colorbar()
pl.savefig(fname)
def test1_2d_esmf_native_tripolar_fraction(self):
mype = MPI.COMM_WORLD.Get_rank()
f = cdms2.open(cdat_info.get_sampledata_path() + \
'/so_Omon_ACCESS1-0_historical_r1i1p1_185001-185412_2timesteps.nc')
so = f('so')[0, 0, :, :]
h = cdms2.open(cdat_info.get_sampledata_path() + \
'/so_Omon_HadGEM2-CC_historical_r1i1p1_185912-186911_2timesteps.nc')
hadGEM2Model = h('so')[0, 0, ...]
ny, nx = so.shape
soBounds = so.getGrid().getBounds()
srcLatCorner = numpy.zeros((ny + 1, nx + 1), numpy.float32)
srcLatCorner[:ny, :nx] = soBounds[0][:, :, 0]
srcLatCorner[:ny, nx] = soBounds[0][:ny, nx - 1, 1]
srcLatCorner[ny, nx] = soBounds[0][ny - 1, nx - 1, 2]
srcLatCorner[ny, :nx] = soBounds[0][ny - 1, :nx, 3]
srcLonCorner = numpy.zeros((ny + 1, nx + 1), numpy.float32)
srcLonCorner[:ny, :nx] = soBounds[1][:, :, 0]
srcLonCorner[:ny, nx] = soBounds[1][:ny, nx - 1, 1]
srcLonCorner[ny, nx] = soBounds[1][ny - 1, nx - 1, 2]
srcLonCorner[ny, :nx] = soBounds[1][ny - 1, :nx, 3]
srcCells = [so.getLatitude(), so.getLongitude()]
srcNodes = [srcLatCorner, srcLonCorner]
clt = cdms2.open(cdat_info.get_sampledata_path() +
'/clt.nc')('clt')[0, :, :]
cltBounds = clt.getGrid().getBounds()
ny, nx = clt.shape
# clt grid is rectilinear, transform to curvilinear
CLGrid = clt.getGrid().toCurveGrid()
#lats = CLGrid.getLatitude()[:].data
lons = CLGrid.getLongitude()[:].data
# Make the bounds go from -90, 90 with uniform spacing and the
# Cell Centers go from -88.something to 88.something
yb = numpy.linspace(-90, 90, ny + 1)
interval = abs(yb[0] - yb[1])
y = numpy.linspace(-90 + interval / 2., 90 - interval / 2., ny)
lats = numpy.outer(y, numpy.ones((nx), numpy.float32))
ny, nx = clt.shape
#yb = numpy.zeros((ny+1,), numpy.float32)
#yb[:ny] = cltBounds[0][:, 0]
#yb[ny] = cltBounds[0][ny-1, 1]
xb = numpy.zeros((nx + 1, ), numpy.float32)
xb[:nx] = cltBounds[1][:, 0]
xb[nx] = cltBounds[1][nx - 1, 1]
# make curvilinear
dstLatCorner = numpy.outer(yb, numpy.ones((nx + 1, ), numpy.float32))
dstLonCorner = numpy.outer(numpy.ones((ny + 1, ), numpy.float32), xb)
dstCells = [lats, lons]
dstNodes = [dstLatCorner, dstLonCorner]
print 'running test2_2d_esmf_native_tripolar_fraction...'
tic = time.time()
# create grid
srcMaxIndex = numpy.array(so.shape[::-1], dtype=numpy.int32)
srcGrid = ESMP.ESMP_GridCreate1PeriDim(
srcMaxIndex, coordSys=ESMP.ESMP_COORDSYS_SPH_DEG)
ESMP.ESMP_GridAddCoord(srcGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
ESMP.ESMP_GridAddCoord(srcGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CORNER)
srcDimsCenter = ESMP.ESMP_GridGetCoord(srcGrid,
ESMP.ESMP_STAGGERLOC_CENTER)
srcDimsCorner = ESMP.ESMP_GridGetCoord(srcGrid,
ESMP.ESMP_STAGGERLOC_CORNER)
srcXCenter = ESMP.ESMP_GridGetCoordPtr(srcGrid, 0,
ESMP.ESMP_STAGGERLOC_CENTER)
srcYCenter = ESMP.ESMP_GridGetCoordPtr(srcGrid, 1,
ESMP.ESMP_STAGGERLOC_CENTER)
srcXCorner = ESMP.ESMP_GridGetCoordPtr(srcGrid, 0,
ESMP.ESMP_STAGGERLOC_CORNER)
srcYCorner = ESMP.ESMP_GridGetCoordPtr(srcGrid, 1,
ESMP.ESMP_STAGGERLOC_CORNER)
dstMaxIndex = numpy.array(clt.shape[::-1], dtype=numpy.int32)
dstGrid = ESMP.ESMP_GridCreate1PeriDim(
dstMaxIndex, coordSys=ESMP.ESMP_COORDSYS_SPH_DEG)
ESMP.ESMP_GridAddCoord(dstGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
ESMP.ESMP_GridAddCoord(dstGrid, staggerloc=ESMP.ESMP_STAGGERLOC_CORNER)
dstDimsCenter = ESMP.ESMP_GridGetCoord(dstGrid,
ESMP.ESMP_STAGGERLOC_CENTER)
dstDimsCorner = ESMP.ESMP_GridGetCoord(dstGrid,
ESMP.ESMP_STAGGERLOC_CORNER)
dstXCenter = ESMP.ESMP_GridGetCoordPtr(dstGrid, 0,
ESMP.ESMP_STAGGERLOC_CENTER)
dstYCenter = ESMP.ESMP_GridGetCoordPtr(dstGrid, 1,
ESMP.ESMP_STAGGERLOC_CENTER)
dstXCorner = ESMP.ESMP_GridGetCoordPtr(dstGrid, 0,
ESMP.ESMP_STAGGERLOC_CORNER)
dstYCorner = ESMP.ESMP_GridGetCoordPtr(dstGrid, 1,
ESMP.ESMP_STAGGERLOC_CORNER)
# mask
ESMP.ESMP_GridAddItem(srcGrid, item=ESMP.ESMP_GRIDITEM_MASK)
srcMask = ESMP.ESMP_GridGetItem(srcGrid, item=ESMP.ESMP_GRIDITEM_MASK)
# create field
srcFld = ESMP.ESMP_FieldCreateGrid(
srcGrid,
'srcFld',
typekind=ESMP.ESMP_TYPEKIND_R4,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
srcFldPtr = ESMP.ESMP_FieldGetPtr(srcFld)
dstFld = ESMP.ESMP_FieldCreateGrid(
dstGrid,
'dstFld',
typekind=ESMP.ESMP_TYPEKIND_R4,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
dstFldPtr = ESMP.ESMP_FieldGetPtr(dstFld)
# Create the field for the fractional areas
srcFracFld = ESMP.ESMP_FieldCreateGrid(
srcGrid,
'srcFrac',
typekind=ESMP.ESMP_TYPEKIND_R4,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
srcFracPtr = ESMP.ESMP_FieldGetPtr(srcFracFld)
dstFracFld = ESMP.ESMP_FieldCreateGrid(
dstGrid,
'dstFrac',
typekind=ESMP.ESMP_TYPEKIND_R4,
staggerloc=ESMP.ESMP_STAGGERLOC_CENTER)
dstFracPtr = ESMP.ESMP_FieldGetPtr(dstFracFld)
# set coords, mask, and field values for src and dst
srcNtotCenter = reduce(operator.mul,
[srcDimsCenter[1][i] - srcDimsCenter[0][i] \
for i in range(2)])
srcNtotCorner = reduce(operator.mul,
[srcDimsCorner[1][i] - srcDimsCorner[0][i] \
for i in range(2)])
srcJCenterBeg = srcDimsCenter[0][1]
srcJCenterEnd = srcDimsCenter[1][1]
srcJCornerBeg = srcDimsCorner[0][1]
srcJCornerEnd = srcDimsCorner[1][1]
srcICenterBeg = srcDimsCenter[0][0]
srcICenterEnd = srcDimsCenter[1][0]
srcICornerBeg = srcDimsCorner[0][0]
srcICornerEnd = srcDimsCorner[1][0]
srcXCenter[:] = numpy.reshape(
srcCells[1][srcJCenterBeg:srcJCenterEnd,
srcICenterBeg:srcICenterEnd], (srcNtotCenter, ))
srcYCenter[:] = numpy.reshape(
srcCells[0][srcJCenterBeg:srcJCenterEnd,
srcICenterBeg:srcICenterEnd], (srcNtotCenter, ))
srcXCorner[:] = numpy.reshape(
srcNodes[1][srcJCornerBeg:srcJCornerEnd,
srcICornerBeg:srcICornerEnd], (srcNtotCorner, ))
srcYCorner[:] = numpy.reshape(
srcNodes[0][srcJCornerBeg:srcJCornerEnd,
srcICornerBeg:srcICornerEnd], (srcNtotCorner, ))
srcFldPtr[:] = numpy.reshape(
so[srcJCenterBeg:srcJCenterEnd, srcICenterBeg:srcICenterEnd],
(srcNtotCenter, ))
srcMask[:] = (srcFldPtr == so.missing_value)
srcFracPtr[:] = -999
dstFracPtr[:] = -999
dstNtotCenter = reduce(
operator.mul,
[dstDimsCenter[1][i] - dstDimsCenter[0][i] for i in range(2)])
dstNtotCorner = reduce(
operator.mul,
[dstDimsCorner[1][i] - dstDimsCorner[0][i] for i in range(2)])
dstXCenter[:] = numpy.reshape(
dstCells[1][dstDimsCenter[0][1]:dstDimsCenter[1][1],
dstDimsCenter[0][0]:dstDimsCenter[1][0]],
(dstNtotCenter))
dstXCenter[:] = numpy.reshape(
dstCells[0][dstDimsCenter[0][1]:dstDimsCenter[1][1],
dstDimsCenter[0][0]:dstDimsCenter[1][0]],
(dstNtotCenter))
dstXCorner[:] = numpy.reshape(
dstNodes[1][dstDimsCorner[0][1]:dstDimsCorner[1][1],
dstDimsCorner[0][0]:dstDimsCorner[1][0]],
(dstNtotCorner, ))
dstYCorner[:] = numpy.reshape(
dstNodes[0][dstDimsCorner[0][1]:dstDimsCorner[1][1],
dstDimsCorner[0][0]:dstDimsCorner[1][0]],
(dstNtotCorner, ))
dstFldPtr[:] = 0
srcAreaFld = ESMP.ESMP_FieldCreateGrid(srcGrid, 'srcArea')
dstAreaFld = ESMP.ESMP_FieldCreateGrid(dstGrid, 'dstArea')
# regrid forward and backward
maskVals = numpy.array([1], numpy.int32) # values defining mask
regrid1 = ESMP.ESMP_FieldRegridStore(
srcFld,
dstFld,
srcMaskValues=maskVals,
dstMaskValues=None,
regridmethod=ESMP.ESMP_REGRIDMETHOD_CONSERVE,
unmappedaction=ESMP.ESMP_UNMAPPEDACTION_IGNORE,
srcFracField=srcFracFld,
dstFracField=dstFracFld)
ESMP.ESMP_FieldRegrid(srcFld, dstFld, regrid1)
srcAreas = ESMP.ESMP_FieldRegridGetArea(srcAreaFld)
dstAreas = ESMP.ESMP_FieldRegridGetArea(dstAreaFld)
srcAreaPtr = ESMP.ESMP_FieldGetPtr(srcAreaFld)
dstAreaPtr = ESMP.ESMP_FieldGetPtr(dstAreaFld)
if mype == 0:
srcHasNan = numpy.any(numpy.isnan(srcFracPtr))
dstHasNan = numpy.any(numpy.isnan(dstFracPtr))
aa = numpy.isnan(srcFracPtr)
bb = numpy.isnan(dstFracPtr)
cc = srcFldPtr == 0
dd = dstFldPtr == 0
if PLOT:
pl.figure(1)
pl.subplot(2, 1, 1)
pl.pcolor(numpy.reshape(aa, so.shape))
pl.colorbar()
pl.title('source')
pl.subplot(2, 1, 2)
pl.pcolor(numpy.reshape(bb, clt.shape))
pl.colorbar()
pl.title('destination')
pl.suptitle("Red == location of nan's")
print srcHasNan, dstHasNan
# Do they have nans?
self.assertFalse(srcHasNan, True)
self.assertFalse(dstHasNan, True)
jbeg, jend = dstDimsCenter[0][1], dstDimsCenter[1][1]
ibeg, iend = dstDimsCenter[0][0], dstDimsCenter[1][0]
soInterp = numpy.reshape(dstFldPtr, (jend - jbeg, iend - ibeg))
toc = time.time()
# clean up
ESMP.ESMP_FieldRegridRelease(regrid1)
ESMP.ESMP_FieldDestroy(dstFld)
ESMP.ESMP_GridDestroy(dstGrid)
ESMP.ESMP_FieldDestroy(srcFld)
ESMP.ESMP_GridDestroy(srcGrid)
plt.figure(1)
#plt.subplot(121)
x = np.linspace(-25.4, +25.4, A.shape[1], endpoint=True)
y = np.linspace(0, 128, A.shape[0], endpoint=True)
x_ds, y_ds = np.meshgrid(x, y)
A = np.where(A > 0, A, 0.0001)
A = np.log10(np.power(A, 2))
print y_ds.shape, x_ds.shape, A.shape
#plt.pcolormesh(x_ds,y_ds, A, cmap=cm.Greys,vmin=-1,vmax=3)
ax = plt.imshow(A,
aspect='auto',
cmap=cm.Greys,
interpolation='nearest',
vmin=-1,
origin='lower')
plt.colorbar()
#plt.ylim(0, 128)
#plt.xlim(-25.4,25.4)
plt.ylabel(r"Lag $\tau$ ")
plt.title(r"$|\tilde{E}(\tau,f_D)|$")
plt.xlabel(r"Doppler Frequency $f_D$ ")
#plt.subplot(122)
fig.add_subplot(gs[:2, 2:4])
bina = 1
binb = 1
a_num = cj.shape[0]
b_num = cj.shape[1]
a_vv = np.copy(cj.reshape(a_num // bina, bina, b_num // binb, binb))
cj = np.mean(np.mean(a_vv, axis=3), axis=1)
cj = np.abs(cj)
cj = np.where(cj > 0, cj, 0.0001)
def exampleNetworks():
names = [
u'Yoachim, P', u'Bellm, E', u'Williams, B', u'Williams, B',
u'Capelo, P'
]
# add some caching so it only querries once.
if not hasattr(exampleNetworks, 'results'):
exampleNetworks.results = [None for name in names]
exampleNetworks.graphs = [None for name in names]
years = [2007, 2011, 2002, 2010, 2012]
texts = ['(a)', '(b)', '(c)', '(d)', '(e)']
count = 1
figs = []
filenames = []
for name, year, txt in zip(names, years, texts):
fig, ax = plt.subplots()
figDummy, axDummy = plt.subplots()
phdA = list(
ads.SearchQuery(q=u'bibstem:*PhDT',
author=name,
year=year,
database='astronomy'))[-1]
if exampleNetworks.results[count - 1] is None:
result, graph = phdArticle2row(phdA,
checkUSA=False,
verbose=True,
returnNetwork=True)
exampleNetworks.results[count - 1] = result
exampleNetworks.graphs[count - 1] = graph
else:
result = exampleNetworks.results[count - 1]
graph = exampleNetworks.graphs[count - 1]
years = []
for node in graph.nodes():
years.append(float(node[0:4]))
years = np.array(years)
# Make the graph repeatable
pos = {}
for i, node in enumerate(graph.nodes()):
pos[node] = (years[i], i**2)
layout = nx.spring_layout(graph, pos=pos)
nx.draw_networkx(graph,
pos=layout,
ax=ax,
node_size=100,
node_color=years,
alpha=0.5,
with_labels=False)
#nx.draw_spring(graph, ax=ax, node_size=100,
# node_color=years, alpha=0.5, with_labels=False)
mappableDummy = axDummy.scatter(years, years, c=years)
cbar = plt.colorbar(mappableDummy, ax=ax, format='%i')
cbar.set_label('Year')
ax.text(.1, .8, txt, fontsize=24, transform=ax.transAxes)
ax.set_axis_off()
figs.append(fig)
filenames.append('example_network_%i' % count)
count += 1
print result
return figs, filenames
def autocorrect(out, ant_str='ant1-13', brange=[0, 300]):
nt = len(out['time'])
nf = len(out['fghz'])
pfac1 = (out['p'][:, :, :, :-1] -
out['p'][:, :, :, 1:]) / out['p'][:, :, :, :-1]
trange = Time(out['time'][[0, -1]], format='jd')
src_lev = gc.get_fem_level(trange) # Read FEM levels from SQL
# Match times with data
tidx = nearest_val_idx(out['time'], src_lev['times'].jd)
# Find attenuation changes
for ant in range(13):
for pol in range(2):
if pol == 0:
lev = src_lev['hlev'][ant, tidx]
else:
lev = src_lev['vlev'][ant, tidx]
jidx, = np.where(abs(lev[:-1] - lev[1:]) == 1)
for freq in range(nf):
idx, = np.where(
np.logical_and(
abs(pfac1[ant, pol, freq]) > 0.05,
abs(pfac1[ant, pol, freq]) < 0.95))
for i in range(len(idx - 1)):
if idx[i] in jidx or idx[i] in jidx - 1:
out['p'][ant, pol, freq, idx[i] +
1:] /= (1 - pfac1[ant, pol, freq, idx[i]])
# Time of total power calibration is 20 UT on the date given
tptime = Time(np.floor(trange[0].mjd) + 20. / 24., format='mjd')
calfac = pc.get_calfac(tptime)
tpcalfac = calfac['tpcalfac']
tpoffsun = calfac['tpoffsun']
hlev = src_lev['hlev'][:13, 0]
vlev = src_lev['vlev'][:13, 0]
attn_dict = ac.read_attncal(trange[0])[0] # Read GCAL attn from SQL
attn = np.zeros((13, 2, nf))
for i in range(13):
attn[i, 0] = attn_dict['attn'][hlev[i], 0, 0]
attn[i, 1] = attn_dict['attn'][vlev[i], 0, 1]
print 'Ant', i + 1, attn[i, 0, 20], attn[i, 1, 20]
attnfac = 10**(attn / 10.)
for i in range(13):
print attnfac[i, 0, 20], attnfac[i, 1, 20]
for i in range(nt):
out['p'][:13, :, :,
i] = (out['p'][:13, :, :, i] * attnfac - tpoffsun) * tpcalfac
antlist = ant_str2list(ant_str)
bg = np.zeros_like(out['p'])
# Subtract background for each antenna/polarization
for ant in antlist:
for pol in range(2):
bg[ant,
pol] = np.median(out['p'][ant, pol, :, brange[0]:brange[1]],
1).repeat(nt).reshape(nf, nt)
#out['p'][ant,pol] -= bg
# Form median over antennas/pols
med = np.mean(np.median((out['p'] - bg)[antlist], 0), 0)
# Do background subtraction once more for good measure
bgd = np.median(med[:, brange[0]:brange[1]], 1).repeat(nt).reshape(nf, nt)
med -= bgd
pdata = np.log10(med)
f, ax = plt.subplots(1, 1)
vmax = np.median(np.nanmax(pdata, 1))
im = ax.pcolormesh(Time(out['time'], format='jd').plot_date,
out['fghz'],
pdata,
vmin=1,
vmax=vmax)
ax.axvspan(Time(out['time'][brange[0]], format='jd').plot_date,
Time(out['time'][brange[1]], format='jd').plot_date,
color='w',
alpha=0.3)
cbar = plt.colorbar(im, ax=ax)
cbar.set_label('Log Flux Density [sfu]')
ax.xaxis_date()
ax.xaxis.set_major_formatter(DateFormatter("%H:%M"))
ax.set_ylim(out['fghz'][0], out['fghz'][-1])
ax.set_xlabel('Time [UT]')
ax.set_ylabel('Frequency [GHz]')
return {'caldata': out, 'med_sub': med, 'bgd': bg}
def Uimg(self,
x,
t,
exactu,
predu,
label='test',
label2='test',
savename='u',
isCycle=False):
X, T = np.meshgrid(x, t) #[100,256]
X_star = np.hstack(
(X.flatten()[:, None], T.flatten()[:, None])) # [25600,2]
# exactu [25,100]
us = [exactu.T, predu.T]
#pdb.set_trace()
# u of exact nu (row0) -> pred nu (row1)
fig, axes = plt.subplots(nrows=2)
for row, u in enumerate(us):
# u[100,25]
u_star = u.flatten()[:, None] # [25600,1]
# [100,100]
U_star = griddata(X_star, u_star.flatten(), (X, T), method='cubic')
#pdb.set_trace()
img = axes[row].imshow(U_star.T,
interpolation='nearest',
cmap='gray',
origin='lower')
if isCycle:
if row == 0:
#pdb.set_trace()
titlelabel = ['exact nu=', 'lloss']
axes[row].set_title(
'%s %.3f %s %.10f' %
(titlelabel[0], np.float(label.split('_')[row]),
titlelabel[1], np.float(label2.split('_')[2])))
elif row == 1:
titlelabel = ['predict nu=', 'closs', 'grad']
#axes[row].set_title('%s %.3f %s %.2f %s %.12f' % (titlelabel[0], np.float(label.split('_')[row][1:-1]), titlelabel[1], np.float(label2.split('_')[0][1:-1]), titlelabel[2], np.float(label2.split('_')[1])))
#pdb.set_trace()
axes[row].set_title(
'%s %.5f %s %.10f' %
(titlelabel[0], np.float(label.split('_')[row][1:-1]),
titlelabel[1], np.float(label2.split('_')[0])))
else:
if row == 0:
titlelabel = 'exact nu='
elif row == 1:
titlelabel = 'predict nu='
#pdb.set_trace()
axes[row].set_title(
'%s %5f' %
(titlelabel, np.float(label.split('_')[row][1:-1])))
divider1 = make_axes_locatable(axes[row])
cax1 = divider1.append_axes("right", size="2%", pad=0.1)
plt.colorbar(img, cax=cax1)
axes[row].set_xlabel('t', fontsize=10)
axes[row].set_ylabel('u(t,x)', fontsize=10)
plt.tight_layout()
fpath = os.path.join('figure', f'burgers_{savename}_{self.dataMode}')
isdir = os.path.exists(fpath)
if not isdir:
os.makedirs(fpath)
plt.savefig(os.path.join(fpath, f'{label}.png'))
plt.close()
print('type(ions) is ', type(ions))
ions = np.array(ions, dtype=int) # change list to int array.
print('type(ions) is ', type(ions))
'''
for atom in ions:
folder = str(atom)
print(folder)
'''
#====================================================================================================
# plot the chosen ions type
#====================================================================================================
data = np.loadtxt('test.dat')
#print(data)
scatters = plt.scatter(data[:, 2], data[:, 3], c=data[:, 1], cmap='coolwarm')
cb = plt.colorbar(scatters, pad=0.01)
plt.savefig('point_distribution.pdf')
plt.show()
#====================================================================================================
filename = 'build_noclimb.sh'
print("=============================================================")
flag = input("Do you want to clean earlier results (y or n) \n \
This will delete all the folders in current folder. : ")
if (flag == 'y'):
for folder in os.listdir():
if (os.path.isdir(folder)):
os.system('rm -r ' + folder)
#os.rmdir(folder)
C1 = sp.spatial.distance.cdist(xs, xs)
C2 = sp.spatial.distance.cdist(xt, xt)
C1 /= C1.max()
C2 /= C2.max()
pl.figure()
pl.subplot(121)
pl.imshow(C1)
pl.subplot(122)
pl.imshow(C2)
pl.show()
p = ot.unif(n_samples)
q = ot.unif(n_samples)
gw0, log0 = ot.gromov.gromov_wasserstein(C1,
C2,
p,
q,
'square_loss',
verbose=True,
log=True)
print('Gromov-Wasserstein distances: ' + str(log0['gw_dist']))
pl.figure(1, (10, 5))
pl.imshow(gw0, cmap='jet')
pl.title('Gromov Wasserstein')
pl.colorbar()
pl.show()
def plot_results(filename, ccdnr=1, pngfile=None, panels='residual'):
#
#
#
if (not os.path.isfile(filename)):
raise FileNotFoundError
#
with fits.open(filename) as hdu:
resid = hdu['RESIDUALS'].data[ccdnr - 1, :, :]
errors = hdu['ERRORS'].data[ccdnr - 1, :, :]
chi2r = hdu['CHI2_R'].data[ccdnr - 1, :, :]
rev_start = hdu[0].header['REV0']
rev_end = hdu[0].header['REV1']
#
# calculate sigma_clipped statistics
#
xstat = stats.sigma_clipped_stats(resid, sigma=3, maxiters=3)
#
rawy_array = np.arange(20, 200, 20)
if (panels == 'all'):
fig, ax = plt.subplots(nrows=3, ncols=1, figsize=(10, 10), sharex=True)
im = ax[0].imshow(resid,
vmin=-100,
vmax=100.0,
origin='lower',
cmap=plt.get_cmap('bwr'))
div = make_axes_locatable(ax[0])
cax = div.append_axes("right", size="5%", pad=0.1)
cbar = plt.colorbar(im, cax=cax)
cbar.set_label('E - 8040 (eV)')
ax[0].set_title(f'CCD: {ccdnr}, revs in [{rev_start},{rev_end}]')
ax[0].set_xlabel(
fr'mean={xstat[0]:.1f} eV, st.dev.={xstat[2]:.1f} eV (3-$\sigma$ clipped)'
)
#ax[0].set_xticks(rawy_array)
#
im = ax[1].imshow(errors,
vmin=0.0,
vmax=20.0,
origin='lower',
cmap=plt.get_cmap('bwr'))
div = make_axes_locatable(ax[1])
cax = div.append_axes("right", size="5%", pad=0.1)
cbar = plt.colorbar(im, cax=cax)
cbar.set_label('Error (eV)')
#ax[1].set_title(f'CCD: {ccd}')
#ax[1].set_xticks(rawy_array)
#
im = ax[2].imshow(chi2r,
vmin=1.0,
vmax=2.0,
origin='lower',
cmap=plt.get_cmap('bwr'))
div = make_axes_locatable(ax[2])
cax = div.append_axes("right", size="5%", pad=0.1)
cbar = plt.colorbar(im, cax=cax)
cbar.set_label('Chi2_r')
#ax[2].set_title(f'CCD: {ccd}')
ax[2].set_xticks(rawy_array)
#
if (pngfile is not None):
plt.savefig(pngfile, dpi=100)
plt.show()
else:
fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(10, 6), sharex=True)
im = ax.imshow(resid,
vmin=-100,
vmax=100.0,
origin='lower',
cmap=plt.get_cmap('bwr'))
div = make_axes_locatable(ax)
cax = div.append_axes("right", size="5%", pad=0.1)
cbar = plt.colorbar(im, cax=cax)
cbar.set_label('E - 8040 (eV)')
ax.set_xticks(rawy_array)
ax.set_xlabel('RAWY')
ax.set_ylabel('RAWX')
ax.set_title(
f'CCD: {ccdnr}, revs in [{rev_start},{rev_end}]\n' +
fr'mean={xstat[0]:.1f} eV, st.dev.={xstat[2]:.1f} eV (3-$\sigma$ clipped)'
)
#plt.title(fr'mean={xstat[0]:.1f} eV, st.dev.={xstat[2]:.1f} eV (3-$\sigma$ clipped)',ha='right',fontsize=16)
if (pngfile is not None):
plt.savefig(pngfile, dpi=100)
plt.show()
return
def test_2d(self):
mype = 0
if HAS_MPI:
mype = MPI.COMM_WORLD.Get_rank()
f = cdms2.open(
cdat_info.get_sampledata_path() +
'/so_Omon_ACCESS1-0_historical_r1i1p1_185001-185412_2timesteps.nc')
so = f['so'] # [0, 0, :, :]
clt = cdms2.open(cdat_info.get_sampledata_path() +
'/clt.nc')('clt')[0, :, :]
# ESMF interface, assume so and clt are cell centered
srcGrid = regrid2.esmf.EsmfStructGrid(so[0, 0, ...].shape,
coordSys=ESMF.CoordSys.SPH_DEG,
periodicity=0)
dstGrid = regrid2.esmf.EsmfStructGrid(clt.shape,
coordSys=ESMF.CoordSys.SPH_DEG,
periodicity=0)
grid = [so.getGrid().getLatitude(), so.getGrid().getLongitude()]
srcGrid.setCoords(grid,
staggerloc=ESMF.StaggerLoc.CENTER,
globalIndexing=True)
# convert to curvilinear
ny, nx = clt.shape
y = clt.getGrid().getLatitude()
x = clt.getGrid().getLongitude()
yy = numpy.outer(y, numpy.ones((nx, ), numpy.float32))
xx = numpy.outer(numpy.ones((ny, ), numpy.float32), x)
dstGrid.setCoords([yy, xx],
staggerloc=ESMF.StaggerLoc.CENTER,
globalIndexing=True)
# mask = numpy.zeros(so[0, 0, ...].shape, numpy.int32)
# mask[:] = (so[0, 0, ...] == so.missing_value)
mask = so[0, 0, :].mask
srcGrid.setMask(mask)
srcFld = regrid2.esmf.EsmfStructField(
srcGrid,
'srcFld',
datatype=so[:].dtype,
staggerloc=ESMF.StaggerLoc.CENTER)
srcSlab = srcGrid.getLocalSlab(ESMF.StaggerLoc.CENTER)
dstSlab = dstGrid.getLocalSlab(ESMF.StaggerLoc.CENTER)
srcFld.setLocalData(numpy.array(so[0, 0, srcSlab[0], srcSlab[1]]),
staggerloc=ESMF.StaggerLoc.CENTER)
dstFld = regrid2.esmf.EsmfStructField(
dstGrid,
'dstFld',
datatype=so.dtype,
staggerloc=ESMF.StaggerLoc.CENTER)
dstData = numpy.ones(clt.shape, numpy.float32)[dstSlab[0], dstSlab[1]]
dstFld.setLocalData(so.missing_value * dstData,
staggerloc=ESMF.StaggerLoc.CENTER)
rgrd1 = regrid2.esmf.EsmfRegrid(
srcFld,
dstFld,
srcFrac=None,
dstFrac=None,
srcMaskValues=numpy.array([1], numpy.int32),
dstMaskValues=numpy.array([1], numpy.int32),
regridMethod=ESMF.RegridMethod.BILINEAR,
unMappedAction=ESMF.UnmappedAction.IGNORE)
# now interpolate
rgrd1(srcFld, dstFld)
# get the data on this proc
soInterpEsmfInterface = dstFld.getData(rootPe=None)
# gather the data on proc 0
soInterpEsmfInterfaceRoot = dstFld.getData(rootPe=0)
print(('[%d] esmfInterface chksum = %f' %
(mype, soInterpEsmfInterface.sum())))
if mype == 0:
print(('ROOT esmfInterface chksum = %f' %
soInterpEsmfInterfaceRoot.sum()))
# Native ESMP
srcMaxIndex = numpy.array(so[0, 0, ...].shape[::-1], dtype=numpy.int32)
# srcMaxIndex = numpy.array(so[0, 0, ...].shape, dtype=numpy.int32)
srcGrid = ESMF.Grid(srcMaxIndex,
coord_sys=ESMF.CoordSys.SPH_DEG,
staggerloc=[ESMF.StaggerLoc.CENTER])
# srcGrid = ESMP.ESMP_GridCreateNoPeriDim(srcMaxIndex,
# coordSys = ESMP.ESMP_COORDSYS_SPH_DEG)
# ESMP.ESMP_GridAddCoord(srcGrid,
# staggerloc = ESMF.StaggerLoc.CENTER)
srcDimsCenter = [
srcGrid.lower_bounds[ESMF.StaggerLoc.CENTER],
srcGrid.upper_bounds[ESMF.StaggerLoc.CENTER]
]
# srcDimsCenter = ESMP.ESMP_GridGetCoord(srcGrid,
# ESMF.StaggerLoc.CENTER)
srcXCenter = srcGrid.get_coords(0, staggerloc=ESMF.StaggerLoc.CENTER)
srcYCenter = srcGrid.get_coords(1, staggerloc=ESMF.StaggerLoc.CENTER)
# srcXCenter = ESMP.ESMP_GridGetCoordPtr(srcGrid, 0,
# ESMF.StaggerLoc.CENTER)
# srcYCenter = ESMP.ESMP_GridGetCoordPtr(srcGrid, 1,
# ESMF.StaggerLoc.CENTER)
dstMaxIndex = numpy.array(clt.shape[::-1], dtype=numpy.int32)
# dstMaxIndex = numpy.array(clt.shape, dtype=numpy.int32)
dstGrid = ESMF.Grid(dstMaxIndex,
coord_sys=ESMF.CoordSys.SPH_DEG,
staggerloc=[ESMF.StaggerLoc.CENTER])
# dstGrid = ESMP.ESMP_GridCreateNoPeriDim(dstMaxIndex,
# coordSys = ESMP.ESMP_COORDSYS_SPH_DEG)
# ESMP.ESMP_GridAddCoord(dstGrid,
# staggerloc = ESMF.StaggerLoc.CENTER)
dstDimsCenter = [
dstGrid.lower_bounds[ESMF.StaggerLoc.CENTER],
dstGrid.upper_bounds[ESMF.StaggerLoc.CENTER]
]
# dstDimsCenter = ESMP.ESMP_GridGetCoord(dstGrid,
# ESMF.StaggerLoc.CENTER)
dstXCenter = dstGrid.get_coords(0, staggerloc=ESMF.StaggerLoc.CENTER)
dstYCenter = dstGrid.get_coords(1, staggerloc=ESMF.StaggerLoc.CENTER)
# dstXCenter = ESMP.ESMP_GridGetCoordPtr(dstGrid, 0,
# ESMF.StaggerLoc.CENTER)
# dstYCenter = ESMP.ESMP_GridGetCoordPtr(dstGrid, 1,
# ESMF.StaggerLoc.CENTER)
# mask
srcGrid.add_item(item=ESMF.GridItem.MASK)
# ESMP.ESMP_GridAddItem(srcGrid, item=ESMP.ESMP_GRIDITEM_MASK)
srcMask = srcGrid.get_item(item=ESMF.GridItem.MASK)
# srcMask = ESMP.ESMP_GridGetItem(srcGrid, item=ESMP.ESMP_GRIDITEM_MASK)
# create field
srcFld = ESMF.Field(srcGrid,
name='srcFld',
typekind=ESMF.TypeKind.R4,
staggerloc=ESMF.StaggerLoc.CENTER)
srcFldPtr = srcFld.data
dstFld = ESMF.Field(dstGrid,
name='dstFld',
typekind=ESMF.TypeKind.R4,
staggerloc=ESMF.StaggerLoc.CENTER)
dstFldPtr = dstFld.data
# set coords, mask, and field values for src and dst
srcNtot = reduce(
operator.mul,
[srcDimsCenter[1][i] - srcDimsCenter[0][i] for i in range(2)])
srcXCenter[:] = so.getGrid().getLongitude()[:].T
srcYCenter[:] = so.getGrid().getLatitude()[:].T
srcFldPtr[:] = so[0, 0, :].T
srcMask[:] = (srcFldPtr == so.missing_value)
# clt grid is rectilinear, transform to curvilinear
lons = clt.getGrid().getLongitude()
lats = clt.getGrid().getLatitude()
ny, nx = dstDimsCenter[1][1] - \
dstDimsCenter[0][1], dstDimsCenter[1][0] - dstDimsCenter[0][0]
localLons = lons[dstDimsCenter[0][0]:dstDimsCenter[1][0]]
localLats = lats[dstDimsCenter[0][1]:dstDimsCenter[1][1]]
xx = numpy.outer(localLons, numpy.ones((ny, ), dtype=numpy.float32))
yy = numpy.outer(numpy.ones((nx, ), dtype=numpy.float32), localLats)
dstXCenter[:] = xx
dstYCenter[:] = yy
dstFldPtr[:] = so.missing_value
# regrid forward and backward
maskVals = numpy.array([1], numpy.int32) # values defining mask
regrid1 = ESMF.Regrid(srcFld,
dstFld,
src_mask_values=maskVals,
dst_mask_values=None,
regrid_method=ESMF.RegridMethod.BILINEAR,
unmapped_action=ESMF.UnmappedAction.IGNORE,
src_frac_field=None,
dst_frac_field=None)
regrid1(srcFld, dstFld, zero_region=ESMF.Region.SELECT)
jbeg, jend = dstDimsCenter[0][0], dstDimsCenter[1][0]
ibeg, iend = dstDimsCenter[0][1], dstDimsCenter[1][1]
soInterpESMP = numpy.ma.masked_where((dstFldPtr == so.missing_value),
dstFldPtr).T
soInterpEsmfInterface = numpy.ma.masked_where(
soInterpEsmfInterface == so.missing_value, soInterpEsmfInterface)
soInterpEsmfInterfaceRoot = numpy.ma.masked_where(
soInterpEsmfInterfaceRoot == so.missing_value,
soInterpEsmfInterfaceRoot)
# check local diffs
ntot = reduce(operator.mul, soInterpESMP.shape)
avgdiff = numpy.sum(soInterpEsmfInterface - soInterpESMP) / float(ntot)
self.assertLess(abs(avgdiff), 1.e-7)
# check gather
chksumESMP = numpy.sum(soInterpESMP)
chksumEsmfInterface = numpy.sum(soInterpEsmfInterface)
if HAS_MPI:
chksumsESMP = MPI.COMM_WORLD.gather(chksumESMP, root=0)
else:
chksumsESMP = chksumESMP
print(('[%d] ESMP chksum = %f' % (mype, chksumESMP)))
if mype == 0:
print(('ROOT ESMP chksum = %f' % numpy.sum(chksumsESMP)))
if mype == 0:
chksumESMPRoot = numpy.sum(chksumsESMP)
chksumESMFInterfaceRoot = numpy.sum(soInterpEsmfInterfaceRoot)
self.assertLess(abs(chksumESMFInterfaceRoot - chksumESMPRoot),
1.e-5 * chksumESMPRoot)
if PLOT:
pylab.subplot(2, 2, 1)
pylab.pcolor(so, vmin=20.0, vmax=40.0)
pylab.colorbar()
pylab.title('so')
pylab.subplot(2, 2, 2)
pylab.pcolor(soInterpEsmfInterface - soInterpESMP,
vmin=-0.5,
vmax=0.5)
pylab.colorbar()
pylab.title('[%d] EsmfInterface - ESMP' % mype)
pylab.subplot(2, 2, 3)
pylab.pcolor(soInterpEsmfInterface, vmin=20.0, vmax=40.0)
pylab.colorbar()
pylab.title('[%d] ESMFInterface' % mype)
pylab.subplot(2, 2, 4)
pylab.pcolor(soInterpESMP, vmin=20, vmax=40)
pylab.colorbar()
pylab.title('[%d] ESMP' % mype)
edgecolor_constructor = []
linewidth_constructor = []
counter = 0
for i in range(8):
for j in range(8):
if i == 7-j or i == 8-j:
edgecolor_constructor.append('w')
linewidth_constructor.append(2)
else:
edgecolor_constructor.append('w')
linewidth_constructor.append(.5)
pt.figure()
pt.pcolor( fitness_table[::-1], cmap = 'RdBu', vmin=-8,vmax=8,edgecolors='w', linewidth=.5)
pt.colorbar(label='Median fitness (%)')
ax = pt.gca()
ax.set_xticks(numpy.arange(.5,8.7,1))
ax.set_yticks(numpy.arange(.5,8.7,1))
ax.set_xticklabels(evolution_env_labels,fontsize=8)
ax.set_yticklabels(measurement_env_labels[::-1],fontsize=8)
ax.set_xlim(0,8)
ax.set_ylim(0,8)
ax.tick_params(axis=u'both', which=u'both',length=0)
ax.set_xlabel('Measurement environment',fontsize=14)
ax.set_ylabel('Evolution environment',fontsize=14)
pt.plot([0,8],[8,0],'--',color='Gray',linewidth=.5)
for i in range(8):
for j in range(8):
if fitness_table[i,7-j] < 0 and fitness_table[i,7-j] > -.1: ###This will get printed as -0.0, so print 0.0 instead
ax.text(7-j+.5,7-i+.5,abs(numpy.round(fitness_table[i,7-j],1)),color='Gray',fontsize=7,horizontalalignment='center',verticalalignment='center')
def calc_results(start_rev,
ccdnr=1,
mode='FF',
pngfile=None,
plot_it=True,
stacks_dir=os.getcwd()):
#
# compare the CTI distribution of copper (8 keV) before and after the correction
#
step = 500
file0 = f'{stacks_dir}/{mode}_stacked_{start_rev:04}_{start_rev+step-1:04}_results.fits.gz'
file1 = f'{stacks_dir}/{mode}_stacked_{start_rev:04}_{start_rev+step-1:04}_results_corr.fits.gz'
if (not (os.path.isfile(file0) and os.path.isfile(file1))):
raise FileNotFoundError
#
with fits.open(file0) as hdu0, fits.open(file1) as hdu1:
resid0 = hdu0['RESIDUALS'].data[ccdnr - 1, :, :]
resid1 = hdu1['RESIDUALS'].data[ccdnr - 1, :, :]
#
# calculate sigma_clipped statistics
#
xstat0 = stats.sigma_clipped_stats(resid0, sigma=3, maxiters=3)
xstat1 = stats.sigma_clipped_stats(resid1, sigma=3, maxiters=3)
#
if (plot_it):
rawy_array = np.arange(20, 200, 20)
#
fig, ax = plt.subplots(nrows=2, ncols=1, figsize=(10, 10), sharex=True)
#
im = ax[0].imshow(resid0,
vmin=-100,
vmax=100.0,
origin='lower',
cmap=plt.get_cmap('bwr'))
div = make_axes_locatable(ax[0])
cax = div.append_axes("right", size="5%", pad=0.1)
cbar = plt.colorbar(im, cax=cax)
cbar.set_label('E - 8040 (eV)')
#ax.set_xticks(rawy_array)
ax[0].set_xlabel('RAWY')
#ax.set_ylabel('RAWX')
ax[0].set_title(
f'{mode}, CCD: {ccdnr}, revs in [{start_rev},{start_rev+step-1}]\n mean={xstat0[0]:.1f} eV, st.dev.={xstat0[2]:.1f} eV (3-$\sigma$ clipped)'
)
#plt.title(fr'mean={xstat[0]:.1f} eV, st.dev.={xstat[2]:.1f} eV (3-$\sigma$ clipped)',ha='right',fontsize=16)
im = ax[1].imshow(resid1,
vmin=-100,
vmax=100.0,
origin='lower',
cmap=plt.get_cmap('bwr'))
div = make_axes_locatable(ax[1])
cax = div.append_axes("right", size="5%", pad=0.1)
cbar = plt.colorbar(im, cax=cax)
cbar.set_label('E - 8040 (eV)')
#ax.set_xticks(rawy_array)
ax[1].set_xlabel('RAWY')
ax[1].set_ylabel('RAWX')
ax[1].set_title(
f'Corrected\n mean={xstat1[0]:.1f} eV, st.dev.={xstat1[2]:.1f} eV (3-$\sigma$ clipped)'
)
if (pngfile is not None):
plt.savefig(pngfile, dpi=100)
plt.show()
#time.sleep(10)
plt.close()
else:
plt.show()
return (xstat0, xstat1)
target_pix = wcs.wcs_sky2pix([(np.array([ra,dec], np.float_))], 1)[0]
except:
print "ERROR when converting sky to wcs. Is astrometry in place? Default coordinates assigned."
target_pix = [+nx/2., ny/2.]
print target_pix
else:
target_pix = [+nx/2., ny/2.]
img = img - np.nanmin(img)
av = np.median(img.flatten())
mi, ma = zscale.zscale(img)
im = plt.imshow(plt.log10(img), aspect="equal", extent=(0, ny, 0, nx), \
origin="lower", cmap=matplotlib.cm.gray_r, interpolation="none", vmin=np.log10(av), vmax=np.log10(3*av)) #, interpolation="lanczos")
plt.scatter(target_pix[0], target_pix[1], marker="x", s=10, c="red")
plt.colorbar(im)
filename = os.path.basename(f)
plt.savefig(os.path.join(plot_dir, filename.replace("."+filename.split(".")[-1], "_{:}.png".format(i))), dpi=200)
plt.clf()
def move_to_discarded(mydir, myfilter, ra, dec):
import shutil
for f in glob.glob(os.path.join(mydir, myfilter)):
frames_with_target = get_frames_with_target(f, ra, dec)
if len(frames_with_target) == 0:
discarddir = os.path.join(mydir, "discarded")
if (not os.path.isdir(discarddir)):
print "Creating directory for discarded files (with no target)"
os.makedirs(discarddir)
print "Moving file ",f," to discarded directory",discarddir
def false_hillshade(dH, title, pp=None, clim=(-20, 20)):
"""
Create a map figure showing the differences in black and white...
:param dh: GeoImg object of elevation differences
:param title: Title for plot
:type geoimg: pybob.GeoImg
:type title: str
:returns fig: either prints to a pdf, or returns a figure
"""
niceext = np.array([dH.xmin, dH.xmax, dH.ymin, dH.ymax]) / 1000.
dHtemp = np.ma.masked_invalid(dH.img)
mykeep = np.ma.less(np.ma.abs(dHtemp), np.ma.std(dHtemp) * 3)
# mykeep = np.logical_and.reduce((np.isfinite(dH.img), (np.abs(dH.img) < np.nanstd(dH.img) * 3)))
dH_vec = dHtemp[mykeep]
if pp is not None:
fig = plt.figure(figsize=(7, 5), dpi=300)
else:
fig = plt.figure(figsize=(7, 5))
ax = plt.gca()
im1 = ax.imshow(dH.img, extent=niceext, origin='upper')
ymin = np.ma.mean(dH_vec) - 2 * np.ma.std(dH_vec)
ymax = np.ma.mean(dH_vec) + 2 * np.ma.std(dH_vec)
im1.set_clim(ymin, ymax)
im1.set_cmap('Greys')
# if np.sum(np.isfinite(dH_vec))<10:
# print("Error for statistics in false_hillshade")
# else:
plt.title(title, fontsize=14)
numwid = max([
len('{:.1f} m'.format(np.ma.mean(dH_vec))),
len('{:.1f} m'.format(np.ma.median(dH_vec))),
len('{:.1f} m'.format(np.ma.std(dH_vec)))
])
plt.annotate('MEAN:'.ljust(8) +
('{:.1f} m'.format(np.ma.mean(dH_vec))).rjust(numwid),
xy=(0.65, 0.95),
xycoords='axes fraction',
fontsize=12,
fontweight='bold',
color='red',
family='monospace')
plt.annotate('MEDIAN:'.ljust(8) +
('{:.1f} m'.format(np.ma.median(dH_vec))).rjust(numwid),
xy=(0.65, 0.90),
xycoords='axes fraction',
fontsize=12,
fontweight='bold',
color='red',
family='monospace')
plt.annotate('STD:'.ljust(8) +
('{:.1f} m'.format(np.ma.std(dH_vec))).rjust(numwid),
xy=(0.65, 0.85),
xycoords='axes fraction',
fontsize=12,
fontweight='bold',
color='red',
family='monospace')
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="5%", pad=0.05)
plt.colorbar(im1, cax=cax)
# plt.colorbar(im1)
plt.tight_layout()
gc.collect()
if pp is not None:
pp.savefig(fig, dpi=300)
return
else:
return fig
'''########## SAVE SPREADING OF INFLUENCE GRAPH ON DISK ##########'''
for year, top_results_year in top_results.items():
year_path = constants.TASK_1_PATH + str(year) + '/'
create_clean_folders([year_path])
graph, starting_node, colors, labels = graph_to_save_year[year]
pos = nx.spring_layout(graph, k=0.9, iterations=100) # positions for all nodes)
graph: nx.Graph
print(starting_node)
ec = nx.draw_networkx_edges(graph.to_undirected(), pos, alpha=0.2)
nc = nx.draw_networkx_nodes(graph, pos, nodelist=graph.nodes, node_color=colors,
with_labels=True, node_size=100, cmap=cmap, vmin=vmin, vmax=vmax)
lc = nx.draw_networkx_labels(graph, pos, labels, font_size=5)
cb = plt.colorbar(nc)
cb.set_label('Spreading of influence iteration (-1 if not influenced)')
plt.axis('off')
plt.savefig(year_path + str(starting_node), dpi=500)
plt.close()
influenced_path = year_path + 'spreading of influence/'
create_clean_folders([influenced_path])
for el in top_results_year:
topic = el[0]
score = el[1]
topic_path = influenced_path + str(score) + '_' + topic + '/'
create_clean_folders([topic_path])
infl_nodes = influenced_nodes[year][str(year) + '_' + topic]
f = open(topic_path + 'influenced_nodes.txt', "a")
f.write(str(infl_nodes))
f.close()
qpi.compute_bg(
which_data=["amplitude", "phase"],
fit_offset="fit",
fit_profile="tilt",
border_px=5,
)
# plot the properties of `qpi`
fig = plt.figure(figsize=(8, 10))
matplotlib.rcParams["image.interpolation"] = "bicubic"
holkw = {"cmap": "gray", "vmin": 0, "vmax": 200}
ax1 = plt.subplot(321, title="cell hologram")
map1 = ax1.imshow(edata["data"], **holkw)
plt.colorbar(map1, ax=ax1, fraction=.046, pad=0.04)
ax2 = plt.subplot(322, title="bg hologram")
map2 = ax2.imshow(edata["bg_data"], **holkw)
plt.colorbar(map2, ax=ax2, fraction=.046, pad=0.04)
ax3 = plt.subplot(323, title="input phase [rad]")
map3 = ax3.imshow(pha0)
plt.colorbar(map3, ax=ax3, fraction=.046, pad=0.04)
ax4 = plt.subplot(324, title="input amplitude")
map4 = ax4.imshow(amp0, cmap="gray")
plt.colorbar(map4, ax=ax4, fraction=.046, pad=0.04)
ax5 = plt.subplot(325, title="corrected phase [rad]")
map5 = ax5.imshow(qpi.pha)
#plt.scatter(x,y,c=density, vmin=-0.03, vmax=0.03, cmap='coolwarm') # hot, cool, coolwarm, gnuplot, gnuplot2, bwr, Reds
scatters = plt.scatter(
x / bmag,
y / alat,
c=density * 8.5,
vmin=-0.015,
vmax=0.015,
cmap='coolwarm') # hot, cool, coolwarm, gnuplot, gnuplot2, bwr, Reds
scatters = plt.scatter(
x / bmag, (y + 82.5) / alat,
c=density * 8.5,
vmin=-0.015,
vmax=0.015,
cmap='coolwarm') # hot, cool, coolwarm, gnuplot, gnuplot2, bwr, Reds
cb = plt.colorbar(
scatters, pad=0.01) # pad controls the distance between bar and picture
cb.set_label(label="Charge density (e/S)", size=45)
cb.ax.tick_params(labelsize=35, direction='in')
'''
cb.set_ticks(np.linspace(-0.015,0.015,7,endpoint=True))
#cbarlevels = ('-0.02', '-0.01', '-0.05', '0', '0.05', '0.01', '0.02')
cbarlevels = ('-0.015', '-0.01', '-0.005','0', '0.005','0.01', '0.015')
cb.set_ticklabels(cbarlevels)
plt.clim(-0.015, 0.015) # lim of colorbar
'''
# plot dislocation position with black line
plt.plot(dipole[::2, 0] / bmag - 0.7,
dipole[::2, 1] / alat,
linewidth='5.0',
def showme(mesh,
ifile,
variable='temp',
depth=0,
box=[-180, 180, -90, 90],
res=[360, 180],
influence=80000,
timestep=0,
levels=None,
quiet=None,
ofile=None,
mapproj='rob',
abg=(50, 15, -90),
clim=None,
cmap=None,
interp='nn',
ptype='cf',
k=5):
if cmap:
if cmap in cmo.cmapnames:
colormap = cmo.cmap_d[cmap]
elif cmap in plt.cm.datad:
colormap = plt.get_cmap(cmap)
else:
raise ValueError(
'Get unrecognised name for the colormap `{}`. Colormaps should be from standard matplotlib set of from cmocean package.'
.format(cmap))
else:
if clim:
colormap = cmo.cmap_d['balance']
else:
colormap = plt.get_cmap('Spectral_r')
sstep = timestep
radius_of_influence = influence
left, right, down, up = box
lonNumber, latNumber = res
print(ifile)
flf = Dataset(ifile)
lonreg = np.linspace(left, right, lonNumber)
latreg = np.linspace(down, up, latNumber)
lonreg2, latreg2 = np.meshgrid(lonreg, latreg)
dind = (abs(mesh.zlevs - depth)).argmin()
realdepth = mesh.zlevs[dind]
level_data, nnn = pf.get_data(flf.variables[variable][sstep], mesh,
realdepth)
if interp == 'nn':
ofesom = pf.fesom2regular(level_data,
mesh,
lonreg2,
latreg2,
radius_of_influence=radius_of_influence)
elif interp == 'idist':
ofesom = pf.fesom2regular(level_data,
mesh,
lonreg2,
latreg2,
radius_of_influence=radius_of_influence,
how='idist',
k=k)
elif interp == 'linear':
points = np.vstack((mesh.x2, mesh.y2)).T
qh = qhull.Delaunay(points)
ofesom = LinearNDInterpolator(qh, level_data)((lonreg2, latreg2))
elif interp == 'cubic':
points = np.vstack((mesh.x2, mesh.y2)).T
qh = qhull.Delaunay(points)
ofesom = CloughTocher2DInterpolator(qh, level_data)((lonreg2, latreg2))
if clim:
if variable == 'temp':
climvar = 'T'
elif variable == 'salt':
climvar = 'S'
else:
raise ValueError(
'You have selected --clim/-c option, but variable `{}` is not in climatology. Acceptable values are `temp` and `salt` only.'
.format(variable))
#os.path.join(os.path.dirname(__file__), "../")
pathToClim = os.path.join(os.path.dirname(os.path.realpath(__file__)),
"../../data/")
print(pathToClim)
w = pf.climatology(pathToClim, clim)
xx, yy, oclim = pf.clim2regular(
w,
climvar,
lonreg2,
latreg2,
levels=[realdepth],
radius_of_influence=radius_of_influence)
oclim = oclim[0, :, :]
data = ofesom - oclim
else:
data = ofesom
if mapproj == 'merc':
ax = plt.subplot(111, projection=ccrs.Mercator())
elif mapproj == 'pc':
ax = plt.subplot(111, projection=ccrs.PlateCarree())
elif mapproj == 'np':
ax = plt.subplot(111, projection=ccrs.NorthPolarStereo())
elif mapproj == 'sp':
ax = plt.subplot(111, projection=ccrs.SouthPolarStereo())
elif mapproj == 'rob':
ax = plt.subplot(111, projection=ccrs.Robinson())
ax.set_extent([left, right, down, up], crs=ccrs.PlateCarree())
if levels:
mmin, mmax, nnum = levels
nnum = int(nnum)
else:
mmin = np.nanmin(data)
mmax = np.nanmax(data)
nnum = 40
data_levels = np.linspace(mmin, mmax, nnum)
if ptype == 'cf':
mm = ax.contourf(lonreg,\
latreg,\
data,
levels = data_levels,
transform=ccrs.PlateCarree(),
cmap=colormap,
extend='both')
elif ptype == 'pcm':
data_cyc, lon_cyc = add_cyclic_point(data, coord=lonreg)
mm = ax.pcolormesh(lon_cyc,\
latreg,\
data_cyc,
vmin = mmin,
vmax = mmax,
transform=ccrs.PlateCarree(),
cmap=colormap,
)
else:
raise ValueError('Inknown plot type {}'.format(ptype))
ax.coastlines(resolution='50m', lw=0.5)
ax.add_feature(
cfeature.GSHHSFeature(levels=[1], scale='low', facecolor='lightgray'))
cb = plt.colorbar(mm, orientation='horizontal', pad=0.03)
cb.set_label(flf.variables[variable].units)
plt.title('{} at {}m.'.format(variable, realdepth))
plt.tight_layout()
if ofile:
plt.savefig(ofile, dpi=100)
else:
plt.show()
# phase images
kw = {"vmax": qpi_pbs[dry_masses[1]].pha.max(),
"vmin": qpi_pbs[dry_masses[1]].pha.min()}
ax1 = plt.subplot2grid((2, 3), (0, 2))
ax1.set_title("{}pg (in PBS)".format(dry_masses[0]))
ax1.axis("off")
map1 = ax1.imshow(qpi_pbs[dry_masses[0]].pha, **kw)
ax2 = plt.subplot2grid((2, 3), (1, 2))
ax2.set_title("{}pg (in PBS)".format(dry_masses[1]))
ax2.axis("off")
ax2.imshow(qpi_pbs[dry_masses[1]].pha, **kw)
# overview plot
ax3 = plt.subplot2grid((2, 3), (0, 0), colspan=2, rowspan=2)
ax3.set_xlabel("medium refractive index")
ax3.set_ylabel("computed dry mass [pg]")
for m, c in zip(dry_masses, ["blue", "green"]):
ax3.plot(medium_indices, m_abs[m], ls="solid", color=c,
label="{}pg absolute".format(m))
ax3.plot(medium_indices, m_rel[m], ls="dashed", color=c,
label="{}pg relative".format(m))
ax3.legend()
plt.colorbar(map1, ax=ax3, fraction=.048, pad=0.1,
label="phase [rad]")
plt.tight_layout()
plt.subplots_adjust(wspace=.14)
plt.show()
if not opts.src is None:
sx, sy = map(slons, slats)
for name, xpt, ypt, flx in zip(snams, sx, sy, sflxs):
if xpt >= 1e30 or ypt >= 1e30: continue
if opts.src_mark != '':
map.plot(sx,
sy,
opts.src_color + opts.src_mark,
markerfacecolor=None)
if flx < 10: flx = 10
p.text(xpt + .001,
ypt + .001,
name,
size=5 + 2 * int(np.round(np.log10(flx))),
color=opts.src_color)
if not opts.nobar: p.colorbar(shrink=.5, format='%.2f')
else: p.subplots_adjust(.05, .05, .95, .95)
def mk_arr(val, dtype=np.double):
if type(val) is np.ndarray: return val.astype(dtype)
return np.array(val, dtype=dtype).flatten()
if opts.outfile != '':
print('Saving to', opts.outfile)
p.savefig(opts.outfile)
else:
# Add right-click functionality for finding locations/strengths in map.
cnt = 1
