def plotSIFGI():
a = eqtools.EqdskReader(gfile='/afs/ipp-garching.mpg.de/home/i/ianf/codes/python/general/g33669.3000')
a.remapLCFS()
b = eqtools.AUGDDData(33669)
tok = TRIPPy.Tokamak(b)
cont = (pow(scipy.linspace(0,1,11),2)*(a.getFluxLCFS()-a.getFluxAxis())+a.getFluxAxis())
print(a.getFluxAxis())
print(a.getFluxLCFS())
print(cont)
temp = b.getMachineCrossSectionFull()
plotEq.plot(a,33669,lims=temp,contours=-1*cont)
GI = genGRW(tok)
r = GI.r()[0][-2:]
z = GI.r()[2][-2:]
print(r,z)
plt.plot(r,z,color='#0E525A',linewidth=2.)
SIF = genSIF(tok)
r = SIF.r()[0][-2:]
z = SIF.r()[2][-2:]
print(r,z)
plt.plot(r,z,color='#228B22',linewidth=2.)
plt.subplots_adjust(left=.2,right=.95)
plt.gca().set_xlim([scipy.nanmin(temp[0].astype(float)),scipy.nanmax(temp[0].astype(float))])
plt.gca().set_ylim([scipy.nanmin(temp[1].astype(float)),scipy.nanmax(temp[1].astype(float))])
plt.text(1.4,.9,'CSXR',fontsize=22,zorder=10)
plt.text(2.25,.1,'GI',fontsize=22,zorder=10)
limy = plt.gca().get_ylim()
limx = plt.gca().get_xlim()
plt.gca().text(1.0075*(limx[1]-limx[0])+limx[0],.97*(limy[1]-limy[0])+limy[0],str(33669),rotation=90,fontsize=14)
def min_filter_bord(im, size=3):
"""The function performs a local min filter on a flat image. Border's
pixels are processed.
Args:
im: the image to process
size: the size in pixels of the local square window. Default value is 3.
Returns:
out: the filtered image
"""
## Get the size of the image
[nl, nc, d] = im.shape
## Get the size of the moving window
s = (size - 1) / 2
## Initialization of the output
out = sp.empty((nl, nc, d))
temp = sp.empty((nl + 2 * s, nc + 2 * s, d)) # A temporary file is created
temp[0:s, :] = sp.NaN
temp[:, 0:s] = sp.NaN
temp[-s:, :] = sp.NaN
temp[:, -s:] = sp.NaN
temp[s : s + nl, s : nc + s] = im
## Apply the max filter
for i in range(s, nl + s): # Shift the origin to remove border effect
for j in range(s, nc + s):
for k in range(d):
out[i - s, j - s, k] = sp.nanmin(temp[i - s : i + 1 + s, j - s : j + s + 1, k])
return out.astype(im.dtype.name)
def CalcStats(samples):
return dict(
zip(['mean', 'max', 'min', 'sdeviation'], [
float(sp.mean(samples)),
float(sp.nanmax(samples)),
float(sp.nanmin(samples)),
float(sp.std(samples))
]))
def to_discrete_dataset(self, dfactor=36, dataset=None):
#get maximum and minimum values
print "getting feature summary"
f_summary = self.get_feature_summary()
print "min/max val"
f_min_max = {}
for name in f_summary.keys():
#if(nan in f_summary[name]):
# print "f_summary[name]", fsummary[name]
#try:
# f_summary[name].remove(nan)
#except:
# print "not removed"
#print f_summary, name
#print list(f_summary[name])
min_val = nanmin(list(f_summary[name]))
max_val = nanmax(list(f_summary[name]))
#if(isnan(min_val) or isnan(max_val)):
# print "name:", name, min_val, max_val
#else:
# print "name:", name, min_val, max_val
# print "nan in summary:", nan in f_summary[name]
# print "set:", f_summary[name]
# print "dataset.py: error neither should be nan"
# exit(0)
f_min_max[name] = [min_val, max_val]
#print name, [min_val, max_val]
#raw_input()
# print "computed keys"
# for key in f_min_max.keys():
# if "3d" in key and "w_pick" in key:
# print key, f_min_max[key]
#convert other datset if applicable
if (dataset == None):
observations = self.observations
else:
observations = dataset
obs_discrete = []
print "converting observations"
for o in observations:
dobs = o.to_discrete_observation(f_min_max, dfactor=dfactor)
dobs.annotation = o.annotation
obs_discrete.append(dobs)
print "constructing dataset"
return DiscreteDataset(
obs_discrete,
dfactor,
f_min_max=f_min_max,
feature_extractor_cls=self.feature_extractor_cls)
def get_ls_ls_market_price_dispersion(ls_ls_market_ids, master_price, series):
# if numpy.version.version = '1.8' or above => switch from scipy to numpy
# checks nb of prices (non nan) per period (must be 2 prices at least)
ls_ls_market_price_dispersion = []
for ls_market_ids in ls_ls_market_ids:
list_market_prices = [master_price[series][master_price['ids'].index(indiv_id)] for indiv_id in ls_market_ids]
arr_market_prices = np.array(list_market_prices, dtype = np.float32)
arr_nb_market_prices = (~np.isnan(arr_market_prices)).sum(0)
arr_bool_enough_market_prices = np.where(arr_nb_market_prices > 1, 1, np.nan)
arr_market_prices = arr_bool_enough_market_prices * arr_market_prices
range_price_array = scipy.nanmax(arr_market_prices, 0) - scipy.nanmin(arr_market_prices, axis = 0)
std_price_array = scipy.stats.nanstd(arr_market_prices, 0)
coeff_var_price_array = scipy.stats.nanstd(arr_market_prices, 0) / scipy.stats.nanmean(arr_market_prices, 0)
gain_from_search_array = scipy.stats.nanmean(arr_market_prices, 0) - scipy.nanmin(arr_market_prices, axis = 0)
list_list_market_price_dispersion.append(( ls_market_ids,
len(ls_market_ids),
range_price_array,
std_price_array,
coeff_var_price_array,
gain_from_search_array ))
return list_list_market_price_dispersion
def sky(self):
if self.skyid is None:
skymax = scipy.nanmax(self.varspec)
scimax = scipy.nanmax(self.current)
scimin = scipy.nanmin(self.current)
spec = self.varspec * scimax / skymax - abs(scimin)
self.skyid = len(self.axes.lines)
pylab.plot(self.wave, spec, color='green')
else:
self.axes.lines.remove(self.axes.lines[self.skyid])
self.skyid = None
pylab.draw()
def get_cb_ticks(values):
min_tick = sp.nanmin(values)
max_tick = sp.nanmax(values)
med_tick = min_tick + (max_tick - min_tick) / 2.0
if max_tick > 1.0:
min_tick = sp.ceil(min_tick)
max_tick = sp.floor(max_tick)
med_tick = sp.around(med_tick)
else:
min_tick = sp.ceil(min_tick * 100.0) / 100.0
max_tick = sp.floor(max_tick * 100.0) / 100.0
med_tick = sp.around(med_tick, 2)
return [min_tick, med_tick, max_tick]
def process(path, gene_name):
outpath = name_figpath(path, gene_name)
fin = h5py.File(path, 'r')
pv = fin['pv'][:]
if sp.nanmin(pv) < THOLD:
pos = fin['pos'][:]
plotter.makeManhattanPlot(pv, pos, thold_denom=THOLD_DENOM)
if not os.path.exists(os.path.dirname(outpath)):
os.makedirs(os.path.dirname(outpath))
print "Writing %s" % outpath
plotter.plt.savefig(outpath, dpi=100)
if WRITE_PDF_PLOTS: save_as_pdf(outpath)
plotter.plt.close()
return
def weights2(inp, te, shot, time):
""" pull out data vs time necessary to calculate the weights"""
#condition initialized values
output = scipy.zeros((len(time), 2))
r = inp[0]
z = inp[1]
l = inp[2]
#load GIW ne, Te data
tped = goodGIW(time, shot, name="t_e_ped")
tcore = goodGIW(time, shot, name="t_e_core")
nped = goodGIW(time, shot, name="n_e_ped")
ncore = goodGIW(time, shot, name="n_e_core")
good = scipy.arange(len(time))[scipy.logical_and(
ncore != 0, tcore != 0)] #take only good data
#use spline of the GIW data to solve for the proper Te, otherwise dont evaluate
logte = scipy.log(te)
halfte = scipy.exp(logte[1:] / 2. +
logte[:-1] / 2.) #not going to worry about endpoints
# because I trust te is big enough to be larger than the range of the profile
#step 1, use array of r,z values to solve for rho
eq = eqtools.AUGDDData(shot)
rho = eq.rz2rho('psinorm', r, z, time[good], each_t=True,
sqrt=True) #solve at each time
rhomin = scipy.nanmin(rho, axis=1)
temax = GIWprofiles.te(rhomin, tcore[good], tped[good])
idx = 0
#step 2, construct 2 splines of l(rho)
for i in good:
temp = calcArealDens(l, te, halfte, rho[idx], tped[i], tcore[i],
nped[i], ncore[i])
temp[scipy.logical_not(scipy.isfinite(temp))] = 0.
temp = scipy.sum(temp)
output[i, 0] = temp
output[i, 1] = temax[idx]
idx += 1
#print(idx),
#step 8, return values for storage
return output
def processDebug1(self, rawImagePath):
logger.info("using standard Andor 0 process function")
rawArray = self.read(rawImagePath)
if not self.optionsDict["process?"]:
return rawArray
[atomsArray, lightArray] = self.fastKineticsCrop(rawArray, 2)
if self.optionsDict["darkSubtraction"]:
darkArray = self.loadDarkImage(self.darkImagePath)
rawArray -= darkArray
rawArray.clip(1)
logger.info("atomsArray = %s" % atomsArray)
logger.info("lightArray = %s" % lightArray)
logger.info("atomsArray/lightArray = %s" % (atomsArray / lightArray))
logger.info("min , max atoms = %s, %s" %
(scipy.nanmin(atomsArray), scipy.nanmax(atomsArray)))
logger.info("min , max light = %s, %s" %
(scipy.nanmin(lightArray), scipy.nanmax(lightArray)))
logger.info("min , max atoms/light = %s, %s" % (scipy.nanmin(
atomsArray / lightArray), scipy.nanmax(atomsArray / lightArray)))
corrected = atomsArray / lightArray
if self.optionsDict["rotate?"]:
rotated = self.rotate(corrected, self.optionsDict["rotationAngle"])
return rotated
def _statisticsButton_fired(self):
from scipy.stats import pearsonr
xs, ys = self.dataSets[self.selectedDataSet]
mean = scipy.mean(ys)
median = scipy.median(ys)
std = scipy.std(ys)
minimum = scipy.nanmin(ys)
maximum = scipy.nanmax(ys)
peakToPeak = maximum - minimum
pearsonCorrelation = pearsonr(xs, ys)
resultString = "mean=%G , median=%G stdev =%G\nmin=%G,max=%G, pk-pk=%G\nPearson Correlation=(%G,%G)\n(stdev/mean)=%G" % (
mean, median, std, minimum, maximum, peakToPeak,
pearsonCorrelation[0], pearsonCorrelation[1], std / mean)
self.statisticsString = resultString
def getImageData(self, imageFile):
logger.debug("pulling image data")
# The xs and ys used for the image plot range need to be the
# edges of the cells.
self.imageFile = imageFile
self.xs = scipy.linspace(0.0, self.pixelsX - 1, self.pixelsX)
self.ys = scipy.linspace(0.0, self.pixelsY - 1, self.pixelsY)
if not os.path.exists(imageFile):
#if no file is define the image is flat 0s of camera size
logger.error("image file not found. filling with zeros")
self.zs = scipy.zeros((self.pixelsX, self.pixelsY))
print self.zs
self.minZ = 0.0
self.maxZ = 1.0
self.model_changed = True
else:
try:
self.rawImage = scipy.misc.imread(imageFile)
self.zs = (self.rawImage - self.offset) / self.scale
if self.ODCorrectionBool:
logger.info("Correcting for OD saturation")
self.zs = scipy.log(
(1.0 - scipy.exp(-self.ODSaturationValue)) /
(scipy.exp(-self.zs) -
scipy.exp(-self.ODSaturationValue)))
#we should account for the fact if ODSaturation value is wrong or there is noise we can get complex numbers!
self.zs[scipy.imag(self.zs) > 0] = scipy.nan
self.zs = self.zs.astype(float)
self.minZ = scipy.nanmin(self.zs)
self.maxZ = scipy.nanmax(self.zs)
self.model_changed = True
for fit in self.fitList:
fit.xs = self.xs
fit.ys = self.ys
fit.zs = self.zs
except Exception as e:
logger.error("error in setting data %s" % e.message)
logger.debug(
"Sometimes we get an error unsupported operand type(s) for -: 'instance' and 'float'. "
)
logger.debug(
"checking for what could cause this . Tell Tim if you see this error message!!!!"
)
logger.debug("type(self.rawImage) -> %s" %
type(self.rawImage))
logger.debug("type(self.offset) -> %s" % type(self.offset))
def bovy_dens2d(X, **kwargs):
"""
NAME:
bovy_dens2d
PURPOSE:
plot a 2d density with optional contours
INPUT:
first argument is the density
matplotlib.pyplot.imshow keywords (see http://matplotlib.sourceforge.net/api/axes_api.html#matplotlib.axes.Axes.imshow)
xlabel - (raw string!) x-axis label, LaTeX math mode, no $s needed
ylabel - (raw string!) y-axis label, LaTeX math mode, no $s needed
xrange
yrange
noaxes - don't plot any axes
overplot - if True, overplot
Contours:
contours - if True, draw contours (10 by default)
levels - contour-levels
cntrmass - if True, the density is a probability and the levels
are probability masses contained within the contour
cntrcolors - colors for contours (single color or array)
cntrlabel - label the contours
cntrlw, cntrls - linewidths and linestyles for contour
cntrlabelsize, cntrlabelcolors,cntrinline - contour arguments
OUTPUT:
HISTORY:
2010-03-09 - Written - Bovy (NYU)
"""
if 'overplot' in kwargs:
overplot = kwargs['overplot']
kwargs.pop('overplot')
else:
overplot = False
if not overplot:
pyplot.figure()
ax = pyplot.gca()
ax.set_autoscale_on(False)
if 'xlabel' in kwargs:
xlabel = kwargs['xlabel']
kwargs.pop('xlabel')
else:
xlabel = None
if 'ylabel' in kwargs:
ylabel = kwargs['ylabel']
kwargs.pop('ylabel')
else:
ylabel = None
if 'extent' in kwargs:
extent = kwargs['extent']
kwargs.pop('extent')
else:
if 'xrange' in kwargs:
xlimits = list(kwargs['xrange'])
kwargs.pop('xrange')
else:
xlimits = [0, X.shape[0]]
if 'yrange' in kwargs:
ylimits = list(kwargs['yrange'])
kwargs.pop('yrange')
else:
ylimits = [0, X.shape[1]]
extent = xlimits + ylimits
if 'noaxes' in kwargs:
noaxes = kwargs['noaxes']
kwargs.pop('noaxes')
else:
noaxes = False
if 'contours' in kwargs and kwargs['contours']:
contours = True
kwargs.pop('contours')
elif kwargs.has_key('levels') or 'cntrmass' in kwargs:
contours = True
else:
contours = False
if 'contours' in kwargs:
kwargs.pop('contours')
if 'levels' in kwargs:
levels = kwargs['levels']
kwargs.pop('levels')
elif contours:
if 'cntrmass' in kwargs and kwargs['cntrmass']:
levels = sc.linspace(0., 1., _DEFAULTNCNTR)
elif True in sc.isnan(sc.array(X)):
levels = sc.linspace(sc.nanmin(X), sc.nanmax(X), _DEFAULTNCNTR)
else:
levels = sc.linspace(sc.amin(X), sc.amax(X), _DEFAULTNCNTR)
if 'cntrmass' in kwargs and kwargs['cntrmass']:
cntrmass = True
kwargs.pop('cntrmass')
else:
cntrmass = False
if 'cntrmass' in kwargs: kwargs.pop('cntrmass')
if 'cntrcolors' in kwargs:
cntrcolors = kwargs['cntrcolors']
kwargs.pop('cntrcolors')
elif contours:
cntrcolors = 'k'
if 'cntrlabel' in kwargs and kwargs['cntrlabel']:
cntrlabel = True
kwargs.pop('cntrlabel')
else:
cntrlabel = False
if 'cntrlabel' in kwargs: kwargs.pop('cntrlabel')
if 'cntrlw' in kwargs:
cntrlw = kwargs['cntrlw']
kwargs.pop('cntrlw')
elif contours:
cntrlw = None
if 'cntrls' in kwargs:
cntrls = kwargs['cntrls']
kwargs.pop('cntrls')
elif contours:
cntrls = None
if 'cntrlabelsize' in kwargs:
cntrlabelsize = kwargs['cntrlabelsize']
kwargs.pop('cntrlabelsize')
elif contours:
cntrlabelsize = None
if 'cntrlabelcolors' in kwargs:
cntrlabelcolors = kwargs['cntrlabelcolors']
kwargs.pop('cntrlabelcolors')
elif contours:
cntrlabelcolors = None
if 'cntrinline' in kwargs:
cntrinline = kwargs['cntrinline']
kwargs.pop('cntrinline')
elif contours:
cntrinline = None
if 'retCumImage' in kwargs:
retCumImage = kwargs['retCumImage']
kwargs.pop('retCumImage')
else:
retCumImage = False
out = pyplot.imshow(X, extent=extent, **kwargs)
pyplot.axis(extent)
_add_axislabels(xlabel, ylabel)
_add_ticks()
if contours:
if 'aspect' in kwargs:
aspect = kwargs['aspect']
else:
aspect = None
if 'origin' in kwargs:
origin = kwargs['origin']
else:
origin = None
if cntrmass:
#Sum from the top down!
sortindx = sc.argsort(X.flatten())[::-1]
cumul = sc.cumsum(sc.sort(X.flatten())[::-1]) / sc.sum(X.flatten())
cntrThis = sc.zeros(sc.prod(X.shape))
cntrThis[sortindx] = cumul
cntrThis = sc.reshape(cntrThis, X.shape)
else:
cntrThis = X
cont = pyplot.contour(cntrThis,
levels,
colors=cntrcolors,
linewidths=cntrlw,
extent=extent,
aspect=aspect,
linestyles=cntrls,
origin=origin)
if cntrlabel:
pyplot.clabel(cont,
fontsize=cntrlabelsize,
colors=cntrlabelcolors,
inline=cntrinline)
if noaxes:
ax.set_axis_off()
if retCumImage:
return cntrThis
else:
return out
def plotbeamparametersv2(times, configfile, maindir, fitdir='Fitted', params=['Ne'],
filetemplate='params', suptitle='Parameter Comparison',
werrors=False, nelog=True):
"""
This function will plot the desired parameters for each beam along range.
The values of the input and measured parameters will be plotted
Inputs
Times - A list of times that will be plotted.
configfile - The INI file with the simulation parameters that will be useds.
maindir - The directory the images will be saved in.
params - List of Parameter names that will be ploted. These need to match
in the ionocontainer names.
filetemplate - The first part of a the file names.
suptitle - The supertitle for the plots.
werrors - A bools that determines if the errors will be plotted.
"""
sns.set_style("whitegrid")
sns.set_context("notebook")
# rc('text', usetex=True)
maindir = Path(maindir)
ffit = maindir/fitdir/'fitteddata.h5'
inputfiledir = maindir/'Origparams'
(sensdict, simparams) = readconfigfile(configfile)
paramslower = [ip.lower() for ip in params]
Nt = len(times)
Np = len(params)
#Read in fitted data
Ionofit = IonoContainer.readh5(str(ffit))
dataloc = Ionofit.Sphere_Coords
pnames = Ionofit.Param_Names
pnameslower = sp.array([ip.lower() for ip in pnames.flatten()])
p2fit = [sp.argwhere(ip == pnameslower)[0][0]
if ip in pnameslower else None for ip in paramslower]
time2fit = [None]*Nt
# Have to fix this because of time offsets
if times[0] == 0:
times += Ionofit.Time_Vector[0, 0]
for itn, itime in enumerate(times):
filear = sp.argwhere(Ionofit.Time_Vector[:, 0] >= itime)
if len(filear) == 0:
filenum = len(Ionofit.Time_Vector)-1
else:
filenum = sp.argmin(sp.absolute(Ionofit.Time_Vector[:, 0]-itime))
time2fit[itn] = filenum
times_int = [Ionofit.Time_Vector[i] for i in time2fit]
# determine the beams
angles = dataloc[:, 1:]
rng = sp.unique(dataloc[:, 0])
b_arr = np.ascontiguousarray(angles).view(np.dtype((np.void,
angles.dtype.itemsize * angles.shape[1])))
_, idx, invidx = np.unique(b_arr, return_index=True, return_inverse=True)
beamlist = angles[idx]
Nb = beamlist.shape[0]
# Determine which imput files are to be used.
dirlist = sorted(inputfiledir.glob('*.h5'))
dirliststr = [str(i) for i in dirlist]
sortlist, outime, outfilelist,timebeg,timelist_s = IonoContainer.gettimes(dirliststr)
timelist = timebeg.copy()
time2file = [None]*Nt
time2intime = [None]*Nt
# go through times find files and then times in files
for itn, itime in enumerate(times):
filear = sp.argwhere(timelist >= itime)
if len(filear) == 0:
filenum = [len(timelist)-1]
else:
filenum = filear[0]
flist1 = []
timeinflist = []
for ifile in filenum:
filetimes = timelist_s[ifile]
log1 = (filetimes[:, 0] >= times_int[itn][0]) & (filetimes[:, 0] < times_int[itn][1])
log2 = (filetimes[:, 1] > times_int[itn][0]) & (filetimes[:, 1] <= times_int[itn][1])
log3 = (filetimes[:, 0] <= times_int[itn][0]) & (filetimes[:, 1] > times_int[itn][1])
log4 = (filetimes[:, 0] > times_int[itn][0]) & (filetimes[:, 1] < times_int[itn][1])
curtimes1 = sp.where(log1|log2|log3|log4)[0].tolist()
flist1 = flist1+ [ifile]*len(curtimes1)
timeinflist = timeinflist+curtimes1
time2intime[itn] = timeinflist
time2file[itn] = flist1
nfig = int(sp.ceil(Nt*Nb))
imcount = 0
curfilenum = -1
# Loop for the figures
for i_fig in range(nfig):
lines = [None]*2
labels = [None]*2
(figmplf, axmat) = plt.subplots(int(sp.ceil(Np/2)), 2, figsize=(20, 15), facecolor='w')
axvec = axmat.flatten()
# loop that goes through each axis loops through each parameter, beam
# then time.
for ax in axvec:
if imcount >= Nt*Nb*Np:
break
imcount_f = float(imcount)
itime = int(sp.floor(imcount_f/Nb/Np))
iparam = int(imcount_f/Nb-Np*itime)
ibeam = int(imcount_f-(itime*Np*Nb+iparam*Nb))
curbeam = beamlist[ibeam]
altlist = sp.sin(curbeam[1]*sp.pi/180.)*rng
curparm = paramslower[iparam]
# Use Ne from input to compare the ne derived from the power.
if curparm == 'nepow':
curparm_in = 'ne'
else:
curparm_in = curparm
curcoord = sp.zeros(3)
curcoord[1:] = curbeam
for iplot, filenum in enumerate(time2file[itime]):
if curfilenum != filenum:
curfilenum = filenum
datafilename = dirlist[filenum]
Ionoin = IonoContainer.readh5(str(datafilename))
if ('ti' in paramslower) or ('vi' in paramslower):
Ionoin = maketi(Ionoin)
pnames = Ionoin.Param_Names
pnameslowerin = sp.array([ip.lower() for ip in pnames.flatten()])
prmloc = sp.argwhere(curparm_in == pnameslowerin)
if prmloc.size != 0:
curprm = prmloc[0][0]
# build up parameter vector bs the range values by finding the closest point in space in the input
curdata = sp.zeros(len(rng))
for irngn, irng in enumerate(rng):
curcoord[0] = irng
tempin = Ionoin.getclosestsphere(curcoord)[0][time2intime[itime]]
Ntloc = tempin.shape[0]
tempin = sp.reshape(tempin, (Ntloc, len(pnameslowerin)))
curdata[irngn] = tempin[0, curprm]
#actual plotting of the input data
lines[0] = ax.plot(curdata, altlist, marker='o', c='b', linewidth=2)[0]
labels[0] = 'Input Parameters'
# Plot fitted data for the axis
indxkep = np.argwhere(invidx == ibeam)[:, 0]
curfit = Ionofit.Param_List[indxkep, time2fit[itime], p2fit[iparam]]
rng_fit = dataloc[indxkep, 0]
alt_fit = rng_fit*sp.sin(curbeam[1]*sp.pi/180.)
errorexist = 'n'+paramslower[iparam] in pnameslower
if errorexist and werrors:
eparam = sp.argwhere('n'+paramslower[iparam] == pnameslower)[0][0]
curerror = Ionofit.Param_List[indxkep, time2fit[itime], eparam]
lines[1] = ax.errorbar(curfit, alt_fit, xerr=curerror, fmt='-.',
c='g', linewidth=2)[0]
else:
lines[1] = ax.plot(curfit, alt_fit, marker='o', c='g', linewidth=2)[0]
labels[1] = 'Fitted Parameters'
# get and plot the input data
numplots = len(time2file[itime])
# set the limit for the parameter
if curparm == 'vi':
ax.set(xlim=[-1.25*sp.nanmax(sp.absolute(curfit)), 1.25*sp.nanmax(sp.absolute(curfit))])
elif curparm_in != 'ne':
ax.set(xlim=[0.75*sp.nanmin(curfit), sp.minimum(1.25*sp.nanmax(curfit), 8000.)])
elif (curparm_in == 'ne') and nelog:
ax.set_xscale('log')
ax.set_xlabel(params[iparam])
ax.set_ylabel('Alt km')
ax.set_title('{0} vs Altitude, Time: {1}s Az: {2}$^o$ El: {3}$^o$'.format(params[iparam], times[itime], *curbeam))
imcount += 1
# save figure
figmplf.suptitle(suptitle, fontsize=20)
if None in labels:
labels.remove(None)
lines.remove(None)
plt.figlegend(lines, labels, loc = 'lower center', ncol=5, labelspacing=0.)
fname = filetemplate+'_{0:0>3}.png'.format(i_fig)
plt.savefig(fname)
plt.close(figmplf)
ax = Axes3D(fig)
#ax.plot3D(p[:,0], p[:,1], p[:,2]) #Plots the 3D graph - Stationary
def func(
k
): #########One of the input parameters needed for the animation.FuncAnimated which is used for iterating over the new points
step = 10 * k #The step size regulates the speed of the animation, very easy to change, just increase integer to speed up and decrease to slow down
ax.plot3D(p[:step, 0], p[:step, 1], p[:step, 2],
color='g') #For each i integrates the new function
###################################################################################
###Degfining the axes
ax.set_xlim3d([sp.nanmin(p[:, 0]), sp.nanmax(p[:, 0])
]) ########ABLE TO PLOT AXIS EXCLUDING NAN VALUES
ax.set_xlabel('X')
ax.set_ylim3d([sp.nanmin(p[:, 1]), sp.nanmax(p[:, 1])])
ax.set_ylabel('Y')
ax.set_zlim3d([sp.nanmin(p[:, 2]), sp.nanmax(p[:, 2])])
ax.set_zlabel('Z')
###################################################################################
# ax.set_xlim3d([sp.amin(p[:,0]),sp.amax(p[:,0])]) #Axes without considering the nan values
# ax.set_xlabel('X')
#
# ax.set_ylim3d([sp.amin(p[:,1]),sp.amax(p[:,1])])
# ax.set_ylabel('Y')
def plotbeamparametersv2(times,
configfile,
maindir,
fitdir='Fitted',
params=['Ne'],
filetemplate='params',
suptitle='Parameter Comparison',
werrors=False,
nelog=True):
"""
This function will plot the desired parameters for each beam along range.
The values of the input and measured parameters will be plotted
Inputs
Times - A list of times that will be plotted.
configfile - The INI file with the simulation parameters that will be useds.
maindir - The directory the images will be saved in.
params - List of Parameter names that will be ploted. These need to match
in the ionocontainer names.
filetemplate - The first part of a the file names.
suptitle - The supertitle for the plots.
werrors - A bools that determines if the errors will be plotted.
"""
sns.set_style("whitegrid")
sns.set_context("notebook")
# rc('text', usetex=True)
maindir = Path(maindir)
ffit = maindir / fitdir / 'fitteddata.h5'
inputfiledir = maindir / 'Origparams'
(sensdict, simparams) = readconfigfile(configfile)
paramslower = [ip.lower() for ip in params]
Nt = len(times)
Np = len(params)
#Read in fitted data
Ionofit = IonoContainer.readh5(str(ffit))
dataloc = Ionofit.Sphere_Coords
pnames = Ionofit.Param_Names
pnameslower = sp.array([ip.lower() for ip in pnames.flatten()])
p2fit = [
sp.argwhere(ip == pnameslower)[0][0] if ip in pnameslower else None
for ip in paramslower
]
time2fit = [None] * Nt
# Have to fix this because of time offsets
if times[0] == 0:
times += Ionofit.Time_Vector[0, 0]
for itn, itime in enumerate(times):
filear = sp.argwhere(Ionofit.Time_Vector[:, 0] >= itime)
if len(filear) == 0:
filenum = len(Ionofit.Time_Vector) - 1
else:
filenum = sp.argmin(sp.absolute(Ionofit.Time_Vector[:, 0] - itime))
time2fit[itn] = filenum
times_int = [Ionofit.Time_Vector[i] for i in time2fit]
# determine the beams
angles = dataloc[:, 1:]
rng = sp.unique(dataloc[:, 0])
b_arr = np.ascontiguousarray(angles).view(
np.dtype((np.void, angles.dtype.itemsize * angles.shape[1])))
_, idx, invidx = np.unique(b_arr, return_index=True, return_inverse=True)
beamlist = angles[idx]
Nb = beamlist.shape[0]
# Determine which imput files are to be used.
dirlist = sorted(inputfiledir.glob('*.h5'))
dirliststr = [str(i) for i in dirlist]
sortlist, outime, outfilelist, timebeg, timelist_s = IonoContainer.gettimes(
dirliststr)
timelist = timebeg.copy()
time2file = [None] * Nt
time2intime = [None] * Nt
# go through times find files and then times in files
for itn, itime in enumerate(times):
filear = sp.argwhere(timelist >= itime)
if len(filear) == 0:
filenum = [len(timelist) - 1]
else:
filenum = filear[0]
flist1 = []
timeinflist = []
for ifile in filenum:
filetimes = timelist_s[ifile]
log1 = (filetimes[:, 0] >= times_int[itn][0]) & (filetimes[:, 0] <
times_int[itn][1])
log2 = (filetimes[:, 1] > times_int[itn][0]) & (filetimes[:, 1] <=
times_int[itn][1])
log3 = (filetimes[:, 0] <= times_int[itn][0]) & (filetimes[:, 1] >
times_int[itn][1])
log4 = (filetimes[:, 0] > times_int[itn][0]) & (filetimes[:, 1] <
times_int[itn][1])
curtimes1 = sp.where(log1 | log2 | log3 | log4)[0].tolist()
flist1 = flist1 + [ifile] * len(curtimes1)
timeinflist = timeinflist + curtimes1
time2intime[itn] = timeinflist
time2file[itn] = flist1
nfig = int(sp.ceil(Nt * Nb))
imcount = 0
curfilenum = -1
# Loop for the figures
for i_fig in range(nfig):
lines = [None] * 2
labels = [None] * 2
(figmplf, axmat) = plt.subplots(int(sp.ceil(Np / 2)),
2,
figsize=(20, 15),
facecolor='w')
axvec = axmat.flatten()
# loop that goes through each axis loops through each parameter, beam
# then time.
for ax in axvec:
if imcount >= Nt * Nb * Np:
break
imcount_f = float(imcount)
itime = int(sp.floor(imcount_f / Nb / Np))
iparam = int(imcount_f / Nb - Np * itime)
ibeam = int(imcount_f - (itime * Np * Nb + iparam * Nb))
curbeam = beamlist[ibeam]
altlist = sp.sin(curbeam[1] * sp.pi / 180.) * rng
curparm = paramslower[iparam]
# Use Ne from input to compare the ne derived from the power.
if curparm == 'nepow':
curparm_in = 'ne'
else:
curparm_in = curparm
curcoord = sp.zeros(3)
curcoord[1:] = curbeam
for iplot, filenum in enumerate(time2file[itime]):
if curfilenum != filenum:
curfilenum = filenum
datafilename = dirlist[filenum]
Ionoin = IonoContainer.readh5(str(datafilename))
if ('ti' in paramslower) or ('vi' in paramslower):
Ionoin = maketi(Ionoin)
pnames = Ionoin.Param_Names
pnameslowerin = sp.array(
[ip.lower() for ip in pnames.flatten()])
prmloc = sp.argwhere(curparm_in == pnameslowerin)
if prmloc.size != 0:
curprm = prmloc[0][0]
# build up parameter vector bs the range values by finding the closest point in space in the input
curdata = sp.zeros(len(rng))
for irngn, irng in enumerate(rng):
curcoord[0] = irng
tempin = Ionoin.getclosestsphere(curcoord)[0][
time2intime[itime]]
Ntloc = tempin.shape[0]
tempin = sp.reshape(tempin, (Ntloc, len(pnameslowerin)))
curdata[irngn] = tempin[0, curprm]
#actual plotting of the input data
lines[0] = ax.plot(curdata,
altlist,
marker='o',
c='b',
linewidth=2)[0]
labels[0] = 'Input Parameters'
# Plot fitted data for the axis
indxkep = np.argwhere(invidx == ibeam)[:, 0]
curfit = Ionofit.Param_List[indxkep, time2fit[itime],
p2fit[iparam]]
rng_fit = dataloc[indxkep, 0]
alt_fit = rng_fit * sp.sin(curbeam[1] * sp.pi / 180.)
errorexist = 'n' + paramslower[iparam] in pnameslower
if errorexist and werrors:
eparam = sp.argwhere('n' +
paramslower[iparam] == pnameslower)[0][0]
curerror = Ionofit.Param_List[indxkep, time2fit[itime], eparam]
lines[1] = ax.errorbar(curfit,
alt_fit,
xerr=curerror,
fmt='-.',
c='g',
linewidth=2)[0]
else:
lines[1] = ax.plot(curfit,
alt_fit,
marker='o',
c='g',
linewidth=2)[0]
labels[1] = 'Fitted Parameters'
# get and plot the input data
numplots = len(time2file[itime])
# set the limit for the parameter
if curparm == 'vi':
ax.set(xlim=[
-1.25 * sp.nanmax(sp.absolute(curfit)), 1.25 *
sp.nanmax(sp.absolute(curfit))
])
elif curparm_in != 'ne':
ax.set(xlim=[
0.75 * sp.nanmin(curfit),
sp.minimum(1.25 * sp.nanmax(curfit), 8000.)
])
elif (curparm_in == 'ne') and nelog:
ax.set_xscale('log')
ax.set_xlabel(params[iparam])
ax.set_ylabel('Alt km')
ax.set_title(
'{0} vs Altitude, Time: {1}s Az: {2}$^o$ El: {3}$^o$'.format(
params[iparam], times[itime], *curbeam))
imcount += 1
# save figure
figmplf.suptitle(suptitle, fontsize=20)
if None in labels:
labels.remove(None)
lines.remove(None)
plt.figlegend(lines,
labels,
loc='lower center',
ncol=5,
labelspacing=0.)
fname = filetemplate + '_{0:0>3}.png'.format(i_fig)
plt.savefig(fname)
plt.close(figmplf)
#cmd+="\cp -p "+northxyz_grd_path+" "+northxyz_filtered_grd_path+"\n";
#subprocess.call(cmd,shell=True);
out_f=netcdf.netcdf_file(eastxyz_filtered_grd_path,"w",True);
out_f.createDimension("x",x.shape[0]);
out_x=out_f.createVariable("x","f",("x",));
out_x[:]=x[:];
out_x._attributes["actual_range"]=scipy.array([x.min(), x.max()]);
out_f.createDimension("y",y.shape[0]);
out_y=out_f.createVariable("y","f",("y",));
out_y[:]=y[:];
out_y._attributes["actual_range"]=scipy.array([y.min(), y.max()]);
data_out=scipy.arange(x.shape[0]*y.shape[0]);
data_out.shape=(y.shape[0],x.shape[0]);
out_z=out_f.createVariable("z",scipy.dtype("float32").char,("y","x"));
out_z._attributes["actual_range"]=scipy.array([scipy.nanmin(eastvel), scipy.nanmax(eastvel)]);
out_z[:]=eastvel[:];
out_z._attributes["_FillValue"]="nan";
out_f.flush();
out_f.sync();
out_f.close();
exit();
# Write grid files...
cmd ="\nxyz2grd "+eastvel+" "+R+" -G"+eastxyz_filtered_grd_path+" -I120=\n";
cmd+="\nxyz2grd "+northvel+" "+R+" -G"+northxyz_filtered_grd_path+" -I120=\n";
def TVDI_function(inNDVI,inLST,pas=0.02,t=1,s1Min=0.3,s2Max=0.8,ss1Min=0.2,ss2Max=0.8):
"""
Allows to calculates the TVDI.
this function is a modified version of the IDL script published by Monica Garcia:
(Garcia,M., Fernández, N., VillagarcÃa, L., Domingo, F., Puigdefábregas,J. & I. Sandholt. 2014. 2014.
Accuracy of the Temperature–Vegetation Dryness Index using MODIS under water-limited vs.
energy-limited evapotranspiration conditions Remote Sensing of Environment 149, 100-117.)
Input:
inNDVI: NDVI
inLST: land surface temperature
pas: intervall of the NDVI
S1min: lower threshold to determine the interval which will be used to determine the design parameters of LSTmax
S2max: upper threshold to determine the interval which will be used to determine the design parameters of LSTmax
ss1Min: lower threshold to determine the interval which will be used to determine the calculation of parmaètres LSTmin
ss2Max: upper threshold to determine the interval which will be used to determine the design parameters of LSTmin
t : t=0 to use Garcia M method and t=1 to calculate the TVDI without using the threshold .
Output:
TVDI
"""
TVDI=sp.zeros(inLST.shape)
if inNDVI.shape == inLST.shape :
inNdvi=sp.reshape(inNDVI,(inNDVI.size))
inLst=sp.reshape(inLST,(inLST.size))
mini=sp.nanmin(inNdvi) # valeur minimale
maxi=sp.nanmax(inNdvi) # valeur maximale
arg=sp.argsort(inNdvi) #trie et renvoi les indices des valeurs ordonnées
inV=inNdvi[arg] # on récupère les valeurs de NDVI
inT=inLst[arg] # on récupère les valeurs de temperature
# pas de decoupade du NDVI en intervalle
percentileMax=99.0
percentileMin=1.0
nObsMin=5 # la longeur minimale que doit avoir un intervalle pour être considéré
ni= int(round((maxi-mini)/pas ) + 1) # Nombre total d'intervalle
iValMax=0
iValMin=ni
#création des vecteurs de stockage
vx= sp.zeros((ni),dtype="float")
vMaxi=sp.zeros((ni),dtype="float")
vMini=sp.zeros((ni),dtype="float")
vMaxi[0:]=None
vMini[0:]=None
vNpi=sp.zeros((ni),dtype="float")
for k in range (ni):
hi=k*pas + mini # valeur de depart de l'intervalle
hs=k*pas + hi # valeur de fin de l'intervalle
a=sp.where(inV <= hi)
ii=a[0].max()
b=sp.where(inV <= hs)
iis=b[0].max()
vNpi[k]= iis - ii
inTp=inT[ii:iis+1] #recuperation des valeurs de temperature contenues dans cet intervalle
vx[k]=(hs - hi )/2 +hi #recuperation de valeur de NDVI qui se trouve au milieu intervalle
if vNpi[k] > nObsMin : #on teste si l'intervalle defini a suffisamment de valeur
inTp=inTp[sp.argsort(inTp)] #on trie les valeurs de temperature contenu dans cet intervalle
vMaxi[k]=inTp[ int( ( vNpi[k] *percentileMax/100 )) ] #on recupère la valeur de temperature qui correspond au 99em percentile de l'intervalle
vMini[k]=inTp[ int( ( vNpi[k] *percentileMin/100 ))] #on recupère la valeur de temperature qui correspond au 99em percentile de l'intervalle
if k >iValMax:
iValMax=k
if k < iValMin:
iValMin=k
# calcul de LSTmax et LSTmin
if (t==0):
# Dry Edge
# on utilise un seuil inferieur pour trouver la fin de l'intervalle qui va servir pour le calcul de la regression linéaire
# on utilise iValMin et iValMax pour eviter les nan c'est à dire on reste dans les intervalles qui respecte le nObsMin
try:
b=sp.where(vx < s1Min) # seuil inferieur à modifier
ii=sp.nanmax([sp.nanmax(b[0]),iValMin])
b=sp.where(vx < s2Max) # seuil superieur à modifier
iis=sp.nanmin([sp.nanmax(b[0]),iValMax])
# Wet Edge
c=sp.where(vx < ss1Min) # seuil inferieur à modifier
ii2=sp.nanmax([sp.nanmax(c[0]),iValMin])
c=sp.where(vx < ss2Max) # seuil superieur à modifier
iis2=sp.nanmin([sp.nanmax(c[0]),iValMax])
except:
print "problème avec les valeurs inferieures et superieures utilisées"
else:
ii=iValMin
iis=iValMax
ii2=iValMin
iis2=iValMax
#calcul de la regression linéaire
estimation1=sp.stats.linregress(vx[ii:iis+1],vMaxi[ii:iis+1])
#LSTmax= a * NDVI + b
lstmax_a=estimation1[0] #recuperation du paramètre de pente
lstmax_b=estimation1[1] #recuperation du paramètre de l'ordonnée à l'origine
estimation1=sp.stats.linregress(vx[ii2:iis2+1],vMini[ii2:iis2+1])
#LSTmax= a * NDVI + b
lstmin=sp.nanmin(vMini[ii2:iis2+1])
#calcul de TVDI
TVDI=( inLST - lstmin) / ( lstmax_b + (lstmax_a * inNDVI )- lstmin+0.00000001 )
# TVDI=( inLST - lstmin) / ( ( lstmax_b + (lstmax_a * inNDVI ))- lstmin +0.00001 )
else:
print "les deux tableaux n'ont pas la même taille"
exit
return TVDI
def bovy_dens2d(X,**kwargs):
"""
NAME:
bovy_dens2d
PURPOSE:
plot a 2d density with optional contours
INPUT:
first argument is the density
matplotlib.pyplot.imshow keywords (see http://matplotlib.sourceforge.net/api/axes_api.html#matplotlib.axes.Axes.imshow)
xlabel - (raw string!) x-axis label, LaTeX math mode, no $s needed
ylabel - (raw string!) y-axis label, LaTeX math mode, no $s needed
xrange
yrange
noaxes - don't plot any axes
overplot - if True, overplot
colorbar - if True, add colorbar
shrink= colorbar argument: shrink the colorbar by the factor (optional)
conditional - normalize each column separately (for probability densities, i.e., cntrmass=True)
Contours:
justcontours - if True, only draw contours
contours - if True, draw contours (10 by default)
levels - contour-levels
cntrmass - if True, the density is a probability and the levels are probability masses contained within the contour
cntrcolors - colors for contours (single color or array)
cntrlabel - label the contours
cntrlw, cntrls - linewidths and linestyles for contour
cntrlabelsize, cntrlabelcolors,cntrinline - contour arguments
cntrSmooth - use ndimage.gaussian_filter to smooth before contouring
onedhists - if True, make one-d histograms on the sides
onedhistcolor - histogram color
retAxes= return all Axes instances
retCont= return the contour instance
OUTPUT:
plot to output device, Axes instances depending on input
HISTORY:
2010-03-09 - Written - Bovy (NYU)
"""
overplot= kwargs.pop('overplot',False)
if not overplot:
pyplot.figure()
xlabel= kwargs.pop('xlabel',None)
ylabel= kwargs.pop('ylabel',None)
zlabel= kwargs.pop('zlabel',None)
if 'extent' in kwargs:
extent= kwargs.pop('extent')
else:
xlimits= kwargs.pop('xrange',[0,X.shape[1]])
ylimits= kwargs.pop('yrange',[0,X.shape[0]])
extent= xlimits+ylimits
if not 'aspect' in kwargs:
kwargs['aspect']= (xlimits[1]-xlimits[0])/float(ylimits[1]-ylimits[0])
noaxes= kwargs.pop('noaxes',False)
justcontours= kwargs.pop('justcontours',False)
if ('contours' in kwargs and kwargs['contours']) or \
'levels' in kwargs or justcontours or \
('cntrmass' in kwargs and kwargs['cntrmass']):
contours= True
else:
contours= False
kwargs.pop('contours',None)
if 'levels' in kwargs:
levels= kwargs['levels']
kwargs.pop('levels')
elif contours:
if 'cntrmass' in kwargs and kwargs['cntrmass']:
levels= sc.linspace(0.,1.,_DEFAULTNCNTR)
elif True in sc.isnan(sc.array(X)):
levels= sc.linspace(sc.nanmin(X),sc.nanmax(X),_DEFAULTNCNTR)
else:
levels= sc.linspace(sc.amin(X),sc.amax(X),_DEFAULTNCNTR)
cntrmass= kwargs.pop('cntrmass',False)
conditional= kwargs.pop('conditional',False)
cntrcolors= kwargs.pop('cntrcolors','k')
cntrlabel= kwargs.pop('cntrlabel',False)
cntrlw= kwargs.pop('cntrlw',None)
cntrls= kwargs.pop('cntrls',None)
cntrSmooth= kwargs.pop('cntrSmooth',None)
cntrlabelsize= kwargs.pop('cntrlabelsize',None)
cntrlabelcolors= kwargs.pop('cntrlabelcolors',None)
cntrinline= kwargs.pop('cntrinline',None)
retCumImage= kwargs.pop('retCumImage',False)
cb= kwargs.pop('colorbar',False)
shrink= kwargs.pop('shrink',None)
onedhists= kwargs.pop('onedhists',False)
onedhistcolor= kwargs.pop('onedhistcolor','k')
retAxes= kwargs.pop('retAxes',False)
retCont= kwargs.pop('retCont',False)
if onedhists:
if overplot: fig= pyplot.gcf()
else: fig= pyplot.figure()
nullfmt = NullFormatter() # no labels
# definitions for the axes
left, width = 0.1, 0.65
bottom, height = 0.1, 0.65
bottom_h = left_h = left+width
rect_scatter = [left, bottom, width, height]
rect_histx = [left, bottom_h, width, 0.2]
rect_histy = [left_h, bottom, 0.2, height]
axScatter = pyplot.axes(rect_scatter)
axHistx = pyplot.axes(rect_histx)
axHisty = pyplot.axes(rect_histy)
# no labels
axHistx.xaxis.set_major_formatter(nullfmt)
axHistx.yaxis.set_major_formatter(nullfmt)
axHisty.xaxis.set_major_formatter(nullfmt)
axHisty.yaxis.set_major_formatter(nullfmt)
fig.sca(axScatter)
ax=pyplot.gca()
ax.set_autoscale_on(False)
if conditional:
plotthis= X/sc.tile(sc.sum(X,axis=0),(X.shape[1],1))
else:
plotthis= X
if not justcontours:
out= pyplot.imshow(plotthis,extent=extent,**kwargs)
if not overplot:
pyplot.axis(extent)
_add_axislabels(xlabel,ylabel)
_add_ticks()
#Add colorbar
if cb and not justcontours:
if shrink is None:
shrink= sc.amin([float(kwargs.pop('aspect',1.))*0.87,1.])
CB1= pyplot.colorbar(out,shrink=shrink)
if not zlabel is None:
if zlabel[0] != '$':
thiszlabel=r'$'+zlabel+'$'
else:
thiszlabel=zlabel
CB1.set_label(thiszlabel)
if contours or retCumImage:
aspect= kwargs.get('aspect',None)
origin= kwargs.get('origin',None)
if cntrmass:
#Sum from the top down!
plotthis[sc.isnan(plotthis)]= 0.
sortindx= sc.argsort(plotthis.flatten())[::-1]
cumul= sc.cumsum(sc.sort(plotthis.flatten())[::-1])/sc.sum(plotthis.flatten())
cntrThis= sc.zeros(sc.prod(plotthis.shape))
cntrThis[sortindx]= cumul
cntrThis= sc.reshape(cntrThis,plotthis.shape)
else:
cntrThis= plotthis
if contours:
if not cntrSmooth is None:
cntrThis= ndimage.gaussian_filter(cntrThis,cntrSmooth,
mode='nearest')
cont= pyplot.contour(cntrThis,levels,colors=cntrcolors,
linewidths=cntrlw,extent=extent,aspect=aspect,
linestyles=cntrls,origin=origin)
if cntrlabel:
pyplot.clabel(cont,fontsize=cntrlabelsize,
colors=cntrlabelcolors,
inline=cntrinline)
if noaxes:
ax.set_axis_off()
#Add onedhists
if not onedhists:
if retCumImage:
return cntrThis
elif retAxes:
return pyplot.gca()
elif retCont:
return cont
elif justcontours:
return cntrThis
else:
return out
histx= sc.nansum(X.T,axis=1)*m.fabs(ylimits[1]-ylimits[0])/X.shape[1] #nansum bc nan is *no dens value*
histy= sc.nansum(X.T,axis=0)*m.fabs(xlimits[1]-xlimits[0])/X.shape[0]
histx[sc.isnan(histx)]= 0.
histy[sc.isnan(histy)]= 0.
dx= (extent[1]-extent[0])/float(len(histx))
axHistx.plot(sc.linspace(extent[0]+dx,extent[1]-dx,len(histx)),histx,
drawstyle='steps-mid',color=onedhistcolor)
dy= (extent[3]-extent[2])/float(len(histy))
axHisty.plot(histy,sc.linspace(extent[2]+dy,extent[3]-dy,len(histy)),
drawstyle='steps-mid',color=onedhistcolor)
axHistx.set_xlim( axScatter.get_xlim() )
axHisty.set_ylim( axScatter.get_ylim() )
axHistx.set_ylim( 0, 1.2*sc.amax(histx))
axHisty.set_xlim( 0, 1.2*sc.amax(histy))
if retCumImage:
return cntrThis
elif retAxes:
return (axScatter,axHistx,axHisty)
elif justcontours:
return cntrThis
else:
return out
p[disc1,0]=np.nan
p[disc2,0]=np.nan
p[disc3,0]=np.nan
p[steps-1,0]=np.nan
p[steps-1,1]=np.nan
p[steps-1,2]=np.nan
###################################################################################
fig = plt.figure()
ax = Axes3D(fig)
#ax.plot3D(p[:,0], p[:,1], p[:,2]) #Plots the 3D graph - Stationary
def func(k): #########One of the input parameters needed for the animation.FuncAnimated which is used for iterating over the new points
step=50*k #The step size regulates the speed of the animation, very easy to change, just increase integer to speed up and decrease to slow down
ax.plot3D(p[:step, 0], p[:step, 1], p[:step, 2],color='g')#For each i integrates the new function
###################################################################################
###Degfining the axes
ax.set_xlim3d([sp.nanmin(p[:,0]),sp.nanmax(p[:,0])]) ########ABLE TO PLOT AXIS EXCLUDING NAN VALUES
ax.set_xlabel('X')
ax.set_ylim3d([sp.nanmin(p[:,1]),sp.nanmax(p[:,1])])
ax.set_ylabel('Y')
ax.set_zlim3d([sp.nanmin(p[:,2]),sp.nanmax(p[:,2])])
ax.set_zlabel('Z')
lorentz_3D = animation.FuncAnimation(fig, func, frames=100, interval=20,blit=False, repeat=False,save_count=30) ###Actual function which takes in the arguments and plots the animation
plt.show()
def contourGD(geod,axstr,slicenum,vbounds=None,time = 0,gkey = None,cmap=defmap,
fig=None,ax=None,title='',cbar=True,m=None,levels=None):
""" """
poscoords = ['cartesian','wgs84','enu','ecef']
assert geod.coordnames.lower() in poscoords
if geod.coordnames.lower() in ['cartesian','enu','ecef']:
axdict = {'x':0,'y':1,'z':2}
veckeys = ['x','y','z']
elif geod.coordnames.lower() == 'wgs84':
axdict = {'lat':0,'long':1,'alt':2}# shows which row is this coordinate
veckeys = ['long','lat','alt']# shows which is the x, y and z axes for plotting
if type(axstr)==str:
axis=axstr
else:
axis= veckeys[axstr]
veckeys.remove(axis.lower())
veckeys.append(axis.lower())
datacoords = geod.dataloc
xyzvecs = {l:sp.unique(datacoords[:,axdict[l]]) for l in veckeys}
#make matrices
M1,M2 = sp.meshgrid(xyzvecs[veckeys[0]],xyzvecs[veckeys[1]])
slicevec = sp.unique(datacoords[:,axdict[axis]])
min_idx = sp.argmin(sp.absolute(slicevec-slicenum))
slicenum=slicevec[min_idx]
rec_coords = {axdict[veckeys[0]]:M1.flatten(),axdict[veckeys[1]]:M2.flatten(),
axdict[axis]:slicenum*sp.ones(M2.size)}
new_coords = sp.zeros((M1.size,3))
#make coordinates
for ckey in rec_coords.keys():
new_coords[:,ckey] = rec_coords[ckey]
#determine the data name
if gkey is None:
gkey = geod.data.keys[0]
# get the data location, first check if the data can be just reshaped then do a
# search
sliceindx = slicenum==datacoords[:,axdict[axis]]
datacoordred = datacoords[sliceindx]
rstypes = ['C','F','A']
nfounds = True
M1dlfl = datacoordred[:,axdict[veckeys[0]]]
M2dlfl = datacoordred[:,axdict[veckeys[1]]]
for ir in rstypes:
M1dl = sp.reshape(M1dlfl,M1.shape,order =ir)
M2dl = sp.reshape(M2dlfl,M1.shape,order =ir)
if sp.logical_and(sp.allclose(M1dl,M1),sp.allclose(M2dl,M2)):
nfounds=False
break
if nfounds:
dataout = geod.datareducelocation(new_coords,geod.coordnames,gkey)[:,time]
dataout = sp.reshape(dataout,M1.shape)
else:
dataout = sp.reshape(geod.data[gkey][sliceindx,time],M1.shape,order=ir)
title = insertinfo(title,gkey,geod.times[time,0],geod.times[time,1])
if (ax is None) and (fig is None):
fig = plt.figure(facecolor='white')
ax = fig.gca()
elif ax is None:
ax = fig.gca()
if vbounds is None:
vbounds=[sp.nanmin(dataout),sp.nanmax(dataout)]
if levels is None:
levels=sp.linspace(vbounds[0],vbounds[1],5)
if m is None:
ploth = ax.contour(M1,M2,dataout,levels = levels,vmin=vbounds[0], vmax=vbounds[1],cmap = cmap)
ax.axis([xyzvecs[veckeys[0]].min(), xyzvecs[veckeys[0]].max(),
xyzvecs[veckeys[1]].min(), xyzvecs[veckeys[1]].max()])
if cbar:
cbar2 = plt.colorbar(ploth, ax=ax, format='%.0e')
else:
cbar2 = None
ax.set_title(title)
ax.set_xlabel(veckeys[0])
ax.set_ylabel(veckeys[1])
else:
N1,N2 = m(M1,M2)
ploth = ax.contour(N1,N2,dataout,levels = levels,vmin=vbounds[0], vmax=vbounds[1],cmap = cmap)
if cbar:
#cbar2 = m.colorbar(ploth, format='%.0e')
cbar2 = m.colorbar(ploth)
else:
cbar2 = None
return(ploth,cbar2)
def bovy_dens2d(X,**kwargs):
"""
NAME:
bovy_dens2d
PURPOSE:
plot a 2d density with optional contours
INPUT:
first argument is the density
matplotlib.pyplot.imshow keywords (see http://matplotlib.sourceforge.net/api/axes_api.html#matplotlib.axes.Axes.imshow)
xlabel - (raw string!) x-axis label, LaTeX math mode, no $s needed
ylabel - (raw string!) y-axis label, LaTeX math mode, no $s needed
xrange
yrange
noaxes - don't plot any axes
overplot - if True, overplot
colorbar - if True, add colorbar
shrink= colorbar argument: shrink the colorbar by the factor (optional)
Contours:
contours - if True, draw contours (10 by default)
levels - contour-levels
cntrmass - if True, the density is a probability and the levels
are probability masses contained within the contour
cntrcolors - colors for contours (single color or array)
cntrlabel - label the contours
cntrlw, cntrls - linewidths and linestyles for contour
cntrlabelsize, cntrlabelcolors,cntrinline - contour arguments
OUTPUT:
HISTORY:
2010-03-09 - Written - Bovy (NYU)
"""
if kwargs.has_key('overplot'):
overplot= kwargs['overplot']
kwargs.pop('overplot')
else:
overplot= False
if not overplot:
pyplot.figure()
ax=pyplot.gca()
ax.set_autoscale_on(False)
if kwargs.has_key('xlabel'):
xlabel= kwargs['xlabel']
kwargs.pop('xlabel')
else:
xlabel=None
if kwargs.has_key('ylabel'):
ylabel= kwargs['ylabel']
kwargs.pop('ylabel')
else:
ylabel=None
if kwargs.has_key('zlabel'):
zlabel= kwargs['zlabel']
kwargs.pop('zlabel')
else:
zlabel=None
if kwargs.has_key('extent'):
extent= kwargs['extent']
kwargs.pop('extent')
else:
if kwargs.has_key('xrange'):
xlimits=list(kwargs['xrange'])
kwargs.pop('xrange')
else:
xlimits=[0,X.shape[0]]
if kwargs.has_key('yrange'):
ylimits=list(kwargs['yrange'])
kwargs.pop('yrange')
else:
ylimits=[0,X.shape[1]]
extent= xlimits+ylimits
if not kwargs.has_key('aspect'):
kwargs['aspect']= (xlimits[1]-xlimits[0])/float(ylimits[1]-ylimits[0])
if kwargs.has_key('noaxes'):
noaxes= kwargs['noaxes']
kwargs.pop('noaxes')
else:
noaxes= False
if (kwargs.has_key('contours') and kwargs['contours']) or \
kwargs.has_key('levels') or \
(kwargs.has_key('cntrmass') and kwargs['cntrmass']):
contours= True
else:
contours= False
if kwargs.has_key('contours'): kwargs.pop('contours')
if kwargs.has_key('levels'):
levels= kwargs['levels']
kwargs.pop('levels')
elif contours:
if kwargs.has_key('cntrmass') and kwargs['cntrmass']:
levels= sc.linspace(0.,1.,_DEFAULTNCNTR)
elif True in sc.isnan(sc.array(X)):
levels= sc.linspace(sc.nanmin(X),sc.nanmax(X),_DEFAULTNCNTR)
else:
levels= sc.linspace(sc.amin(X),sc.amax(X),_DEFAULTNCNTR)
if kwargs.has_key('cntrmass') and kwargs['cntrmass']:
cntrmass= True
kwargs.pop('cntrmass')
else:
cntrmass= False
if kwargs.has_key('cntrmass'): kwargs.pop('cntrmass')
if kwargs.has_key('cntrcolors'):
cntrcolors= kwargs['cntrcolors']
kwargs.pop('cntrcolors')
elif contours:
cntrcolors='k'
if kwargs.has_key('cntrlabel') and kwargs['cntrlabel']:
cntrlabel= True
kwargs.pop('cntrlabel')
else:
cntrlabel= False
if kwargs.has_key('cntrlabel'): kwargs.pop('cntrlabel')
if kwargs.has_key('cntrlw'):
cntrlw= kwargs['cntrlw']
kwargs.pop('cntrlw')
elif contours:
cntrlw= None
if kwargs.has_key('cntrls'):
cntrls= kwargs['cntrls']
kwargs.pop('cntrls')
elif contours:
cntrls= None
if kwargs.has_key('cntrlabelsize'):
cntrlabelsize= kwargs['cntrlabelsize']
kwargs.pop('cntrlabelsize')
elif contours:
cntrlabelsize= None
if kwargs.has_key('cntrlabelcolors'):
cntrlabelcolors= kwargs['cntrlabelcolors']
kwargs.pop('cntrlabelcolors')
elif contours:
cntrlabelcolors= None
if kwargs.has_key('cntrinline'):
cntrinline= kwargs['cntrinline']
kwargs.pop('cntrinline')
elif contours:
cntrinline= None
if kwargs.has_key('retCumImage'):
retCumImage= kwargs['retCumImage']
kwargs.pop('retCumImage')
else:
retCumImage= False
if kwargs.has_key('colorbar'):
cb= kwargs['colorbar']
kwargs.pop('colorbar')
else:
cb= False
if kwargs.has_key('shrink'):
shrink= kwargs['shrink']
kwargs.pop('shrink')
else:
shrink= None
out= pyplot.imshow(X,extent=extent,**kwargs)
pyplot.axis(extent)
_add_axislabels(xlabel,ylabel)
_add_ticks()
#Add colorbar
if cb:
if shrink is None:
if kwargs.has_key('aspect'):
shrink= sc.amin([float(kwargs['aspect'])*0.87,1.])
else:
shrink= 0.87
CB1= pyplot.colorbar(out,shrink=shrink)
if not zlabel is None:
if zlabel[0] != '$':
thiszlabel=r'$'+zlabel+'$'
else:
thiszlabel=zlabel
CB1.set_label(zlabel)
if contours or retCumImage:
if kwargs.has_key('aspect'):
aspect= kwargs['aspect']
else:
aspect= None
if kwargs.has_key('origin'):
origin= kwargs['origin']
else:
origin= None
if cntrmass:
#Sum from the top down!
X[sc.isnan(X)]= 0.
sortindx= sc.argsort(X.flatten())[::-1]
cumul= sc.cumsum(sc.sort(X.flatten())[::-1])/sc.sum(X.flatten())
cntrThis= sc.zeros(sc.prod(X.shape))
cntrThis[sortindx]= cumul
cntrThis= sc.reshape(cntrThis,X.shape)
else:
cntrThis= X
if contours:
cont= pyplot.contour(cntrThis,levels,colors=cntrcolors,
linewidths=cntrlw,extent=extent,aspect=aspect,
linestyles=cntrls,origin=origin)
if cntrlabel:
pyplot.clabel(cont,fontsize=cntrlabelsize,
colors=cntrlabelcolors,
inline=cntrinline)
if noaxes:
ax.set_axis_off()
if retCumImage:
return cntrThis
else:
return out
def bovy_dens2d(X, **kwargs):
"""
NAME:
bovy_dens2d
PURPOSE:
plot a 2d density with optional contours
INPUT:
first argument is the density
matplotlib.pyplot.imshow keywords (see http://matplotlib.sourceforge.net/api/axes_api.html#matplotlib.axes.Axes.imshow)
xlabel - (raw string!) x-axis label, LaTeX math mode, no $s needed
ylabel - (raw string!) y-axis label, LaTeX math mode, no $s needed
xrange
yrange
noaxes - don't plot any axes
overplot - if True, overplot
colorbar - if True, add colorbar
shrink= colorbar argument: shrink the colorbar by the factor (optional)
Contours:
contours - if True, draw contours (10 by default)
levels - contour-levels
cntrmass - if True, the density is a probability and the levels
are probability masses contained within the contour
cntrcolors - colors for contours (single color or array)
cntrlabel - label the contours
cntrlw, cntrls - linewidths and linestyles for contour
cntrlabelsize, cntrlabelcolors,cntrinline - contour arguments
onedhists - if True, make one-d histograms on the sides
onedhistcolor - histogram color
retAxes= return all Axes instances
OUTPUT:
HISTORY:
2010-03-09 - Written - Bovy (NYU)
"""
if kwargs.has_key('overplot'):
overplot = kwargs['overplot']
kwargs.pop('overplot')
else:
overplot = False
if not overplot:
pyplot.figure()
if kwargs.has_key('xlabel'):
xlabel = kwargs['xlabel']
kwargs.pop('xlabel')
else:
xlabel = None
if kwargs.has_key('ylabel'):
ylabel = kwargs['ylabel']
kwargs.pop('ylabel')
else:
ylabel = None
if kwargs.has_key('zlabel'):
zlabel = kwargs['zlabel']
kwargs.pop('zlabel')
else:
zlabel = None
if kwargs.has_key('extent'):
extent = kwargs['extent']
kwargs.pop('extent')
else:
if kwargs.has_key('xrange'):
xlimits = list(kwargs['xrange'])
kwargs.pop('xrange')
else:
xlimits = [0, X.shape[0]]
if kwargs.has_key('yrange'):
ylimits = list(kwargs['yrange'])
kwargs.pop('yrange')
else:
ylimits = [0, X.shape[1]]
extent = xlimits + ylimits
if not kwargs.has_key('aspect'):
kwargs['aspect'] = (xlimits[1] - xlimits[0]) / float(ylimits[1] -
ylimits[0])
if kwargs.has_key('noaxes'):
noaxes = kwargs['noaxes']
kwargs.pop('noaxes')
else:
noaxes = False
if (kwargs.has_key('contours') and kwargs['contours']) or \
kwargs.has_key('levels') or \
(kwargs.has_key('cntrmass') and kwargs['cntrmass']):
contours = True
else:
contours = False
if kwargs.has_key('contours'): kwargs.pop('contours')
if kwargs.has_key('levels'):
levels = kwargs['levels']
kwargs.pop('levels')
elif contours:
if kwargs.has_key('cntrmass') and kwargs['cntrmass']:
levels = sc.linspace(0., 1., _DEFAULTNCNTR)
elif True in sc.isnan(sc.array(X)):
levels = sc.linspace(sc.nanmin(X), sc.nanmax(X), _DEFAULTNCNTR)
else:
levels = sc.linspace(sc.amin(X), sc.amax(X), _DEFAULTNCNTR)
if kwargs.has_key('cntrmass') and kwargs['cntrmass']:
cntrmass = True
kwargs.pop('cntrmass')
else:
cntrmass = False
if kwargs.has_key('cntrmass'): kwargs.pop('cntrmass')
if kwargs.has_key('cntrcolors'):
cntrcolors = kwargs['cntrcolors']
kwargs.pop('cntrcolors')
elif contours:
cntrcolors = 'k'
if kwargs.has_key('cntrlabel') and kwargs['cntrlabel']:
cntrlabel = True
kwargs.pop('cntrlabel')
else:
cntrlabel = False
if kwargs.has_key('cntrlabel'): kwargs.pop('cntrlabel')
if kwargs.has_key('cntrlw'):
cntrlw = kwargs['cntrlw']
kwargs.pop('cntrlw')
elif contours:
cntrlw = None
if kwargs.has_key('cntrls'):
cntrls = kwargs['cntrls']
kwargs.pop('cntrls')
elif contours:
cntrls = None
if kwargs.has_key('cntrlabelsize'):
cntrlabelsize = kwargs['cntrlabelsize']
kwargs.pop('cntrlabelsize')
elif contours:
cntrlabelsize = None
if kwargs.has_key('cntrlabelcolors'):
cntrlabelcolors = kwargs['cntrlabelcolors']
kwargs.pop('cntrlabelcolors')
elif contours:
cntrlabelcolors = None
if kwargs.has_key('cntrinline'):
cntrinline = kwargs['cntrinline']
kwargs.pop('cntrinline')
elif contours:
cntrinline = None
if kwargs.has_key('retCumImage'):
retCumImage = kwargs['retCumImage']
kwargs.pop('retCumImage')
else:
retCumImage = False
if kwargs.has_key('colorbar'):
cb = kwargs['colorbar']
kwargs.pop('colorbar')
else:
cb = False
if kwargs.has_key('shrink'):
shrink = kwargs['shrink']
kwargs.pop('shrink')
else:
shrink = None
if kwargs.has_key('onedhists'):
onedhists = kwargs['onedhists']
kwargs.pop('onedhists')
else:
onedhists = False
if kwargs.has_key('onedhistcolor'):
onedhistcolor = kwargs['onedhistcolor']
kwargs.pop('onedhistcolor')
else:
onedhistcolor = 'k'
if kwargs.has_key('retAxes'):
retAxes = kwargs['retAxes']
kwargs.pop('retAxes')
else:
retAxes = False
if onedhists:
if overplot: fig = pyplot.gcf()
else: fig = pyplot.figure()
nullfmt = NullFormatter() # no labels
# definitions for the axes
left, width = 0.1, 0.65
bottom, height = 0.1, 0.65
bottom_h = left_h = left + width
rect_scatter = [left, bottom, width, height]
rect_histx = [left, bottom_h, width, 0.2]
rect_histy = [left_h, bottom, 0.2, height]
axScatter = pyplot.axes(rect_scatter)
axHistx = pyplot.axes(rect_histx)
axHisty = pyplot.axes(rect_histy)
# no labels
axHistx.xaxis.set_major_formatter(nullfmt)
axHistx.yaxis.set_major_formatter(nullfmt)
axHisty.xaxis.set_major_formatter(nullfmt)
axHisty.yaxis.set_major_formatter(nullfmt)
fig.sca(axScatter)
ax = pyplot.gca()
ax.set_autoscale_on(False)
out = pyplot.imshow(X, extent=extent, **kwargs)
pyplot.axis(extent)
_add_axislabels(xlabel, ylabel)
_add_ticks()
#Add colorbar
if cb:
if shrink is None:
if kwargs.has_key('aspect'):
shrink = sc.amin([float(kwargs['aspect']) * 0.87, 1.])
else:
shrink = 0.87
CB1 = pyplot.colorbar(out, shrink=shrink)
if not zlabel is None:
if zlabel[0] != '$':
thiszlabel = r'$' + zlabel + '$'
else:
thiszlabel = zlabel
CB1.set_label(zlabel)
if contours or retCumImage:
if kwargs.has_key('aspect'):
aspect = kwargs['aspect']
else:
aspect = None
if kwargs.has_key('origin'):
origin = kwargs['origin']
else:
origin = None
if cntrmass:
#Sum from the top down!
X[sc.isnan(X)] = 0.
sortindx = sc.argsort(X.flatten())[::-1]
cumul = sc.cumsum(sc.sort(X.flatten())[::-1]) / sc.sum(X.flatten())
cntrThis = sc.zeros(sc.prod(X.shape))
cntrThis[sortindx] = cumul
cntrThis = sc.reshape(cntrThis, X.shape)
else:
cntrThis = X
if contours:
cont = pyplot.contour(cntrThis,
levels,
colors=cntrcolors,
linewidths=cntrlw,
extent=extent,
aspect=aspect,
linestyles=cntrls,
origin=origin)
if cntrlabel:
pyplot.clabel(cont,
fontsize=cntrlabelsize,
colors=cntrlabelcolors,
inline=cntrinline)
if noaxes:
ax.set_axis_off()
#Add onedhists
if not onedhists:
if retCumImage:
return cntrThis
elif retAxes:
return pyplot.gca()
else:
return out
histx = sc.nansum(X.T, axis=1) * m.fabs(ylimits[1] - ylimits[0]) / X.shape[
1] #nansum bc nan is *no dens value*
histy = sc.nansum(X.T,
axis=0) * m.fabs(xlimits[1] - xlimits[0]) / X.shape[0]
histx[sc.isnan(histx)] = 0.
histy[sc.isnan(histy)] = 0.
dx = (extent[1] - extent[0]) / float(len(histx))
axHistx.plot(sc.linspace(extent[0] + dx, extent[1] - dx, len(histx)),
histx,
drawstyle='steps-mid',
color=onedhistcolor)
dy = (extent[3] - extent[2]) / float(len(histy))
axHisty.plot(histy,
sc.linspace(extent[2] + dy, extent[3] - dy, len(histy)),
drawstyle='steps-mid',
color=onedhistcolor)
axHistx.set_xlim(axScatter.get_xlim())
axHisty.set_ylim(axScatter.get_ylim())
axHistx.set_ylim(0, 1.2 * sc.amax(histx))
axHisty.set_xlim(0, 1.2 * sc.amax(histy))
if retCumImage:
return cntrThis
elif retAxes:
return (axScatter, axHistx, axHisty)
else:
return out
def _compare_evolutions(self,
evolution1,
evolution2,
*,
primary_to_secondary=False,
flip=True,
min_age=-scipy.inf,
max_age=scipy.inf):
"""
Require the two evolutions match for a, and primary Lconv & Lrad.
Args:
evolution1: The first of the two evolutions to compare.
evolution2: The second of the two evolutions to compare.
primary_to_secondary: If False compares the evolution of the
primary object in both evolutions, otherwise compares the
evolution of the primary in evolution1 to the evolution of the
secondary in evolution2.
flip: If true, also calls itself with the two evolutions swapped.
min_age: Discrepancies at ages before this are ignored.
min_age: Discrepancies at ages after this are ignored.
"""
def output_failing(data):
"""Output to stdout the discrepant evolutions."""
for i in range(max(d.shape[0] for d in data)):
print(
(
'%25.16e %25.16e' % tuple(data[0][i])
if i < data[0].shape[0] else
(51 * ' ')
)
+
' '
+
(
'%25.16e %25.16e' % tuple(data[1][i])
if i < data[1].shape[0] else
(51 * ' ')
)
)
for quantity_name in [
('semimajor', 'semimajor'),
('envelope_angmom', 'primary_envelope_angmom'),
('core_angmom', 'primary_core_angmom')
]:
with self.subTest(quantity=quantity_name[0], flipped=not flip):
if primary_to_secondary:
quantity = [
getattr(
evolution1, quantity_name[0],
getattr(evolution1, quantity_name[1], None)
),
getattr(
evolution2,
(
(
'' if quantity_name[0] == 'semimajor'
else 'secondary_'
)
+
quantity_name[0]
)
)
]
else:
quantity = [
getattr(evol, quantity_name[0],
getattr(evol, quantity_name[1], None))
for evol in [evolution1, evolution2]
]
age_within_range = [
scipy.logical_and(evol.age[:-1] > min_age,
evol.age[:-1] < max_age)
for evol in [evolution1, evolution2]
]
acceptable_ages = scipy.logical_and(
age_within_range[0],
scipy.logical_and(
(evolution1.age[:-1] - evolution1.age[1:]) < 0,
scipy.isfinite(quantity[0][:-1])
)
)
interp_quantity = InterpolatedUnivariateSpline(
evolution1.age[:-1][acceptable_ages],
quantity[0][:-1][acceptable_ages]
)
max_difference = scipy.nanmax(
scipy.fabs(
quantity[1][:-1][age_within_range[1]]
-
interp_quantity(evolution2.age[:-1][age_within_range[1]])
)
)
max_error = max(
(
scipy.nanmax(quantity[1][:-1][age_within_range[1]])
-
scipy.nanmin(quantity[1][:-1][age_within_range[1]])
) * 5e-3,
1e-10 * scipy.nanmean(quantity[1][:-1][age_within_range[1]])
)
if max_difference > max_error:
output_failing(
[
scipy.dstack(
(
evolution1.age[:-1][age_within_range[0]],
quantity[0][:-1][age_within_range[0]]
)
)[0],
scipy.dstack(
(
evolution2.age[:-1][age_within_range[1]],
quantity[1][:-1][age_within_range[1]]
)
)[0]
]
)
self.assertLessEqual(max_difference, max_error)
if flip:
self._compare_evolutions(evolution2,
evolution1,
primary_to_secondary=primary_to_secondary,
min_age=min_age,
max_age=max_age,
flip=False)
def bovy_dens2d(X,**kwargs):
"""
NAME:
bovy_dens2d
PURPOSE:
plot a 2d density with optional contours
INPUT:
first argument is the density
matplotlib.pyplot.imshow keywords (see http://matplotlib.sourceforge.net/api/axes_api.html#matplotlib.axes.Axes.imshow)
xlabel - (raw string!) x-axis label, LaTeX math mode, no $s needed
ylabel - (raw string!) y-axis label, LaTeX math mode, no $s needed
xrange
yrange
noaxes - don't plot any axes
overplot - if True, overplot
colorbar - if True, add colorbar
shrink= colorbar argument: shrink the colorbar by the factor (optional)
Contours:
contours - if True, draw contours (10 by default)
levels - contour-levels
cntrmass - if True, the density is a probability and the levels
are probability masses contained within the contour
cntrcolors - colors for contours (single color or array)
cntrlabel - label the contours
cntrlw, cntrls - linewidths and linestyles for contour
cntrlabelsize, cntrlabelcolors,cntrinline - contour arguments
onedhists - if True, make one-d histograms on the sides
onedhistcolor - histogram color
retAxes= return all Axes instances
OUTPUT:
HISTORY:
2010-03-09 - Written - Bovy (NYU)
"""
if kwargs.has_key('overplot'):
overplot= kwargs['overplot']
kwargs.pop('overplot')
else:
overplot= False
if not overplot:
pyplot.figure()
if kwargs.has_key('xlabel'):
xlabel= kwargs['xlabel']
kwargs.pop('xlabel')
else:
xlabel=None
if kwargs.has_key('ylabel'):
ylabel= kwargs['ylabel']
kwargs.pop('ylabel')
else:
ylabel=None
if kwargs.has_key('zlabel'):
zlabel= kwargs['zlabel']
kwargs.pop('zlabel')
else:
zlabel=None
if kwargs.has_key('extent'):
extent= kwargs['extent']
kwargs.pop('extent')
else:
if kwargs.has_key('xrange'):
xlimits=list(kwargs['xrange'])
kwargs.pop('xrange')
else:
xlimits=[0,X.shape[0]]
if kwargs.has_key('yrange'):
ylimits=list(kwargs['yrange'])
kwargs.pop('yrange')
else:
ylimits=[0,X.shape[1]]
extent= xlimits+ylimits
if not kwargs.has_key('aspect'):
kwargs['aspect']= (xlimits[1]-xlimits[0])/float(ylimits[1]-ylimits[0])
if kwargs.has_key('noaxes'):
noaxes= kwargs['noaxes']
kwargs.pop('noaxes')
else:
noaxes= False
if (kwargs.has_key('contours') and kwargs['contours']) or \
kwargs.has_key('levels') or \
(kwargs.has_key('cntrmass') and kwargs['cntrmass']):
contours= True
else:
contours= False
if kwargs.has_key('contours'): kwargs.pop('contours')
if kwargs.has_key('levels'):
levels= kwargs['levels']
kwargs.pop('levels')
elif contours:
if kwargs.has_key('cntrmass') and kwargs['cntrmass']:
levels= sc.linspace(0.,1.,_DEFAULTNCNTR)
elif True in sc.isnan(sc.array(X)):
levels= sc.linspace(sc.nanmin(X),sc.nanmax(X),_DEFAULTNCNTR)
else:
levels= sc.linspace(sc.amin(X),sc.amax(X),_DEFAULTNCNTR)
if kwargs.has_key('cntrmass') and kwargs['cntrmass']:
cntrmass= True
kwargs.pop('cntrmass')
else:
cntrmass= False
if kwargs.has_key('cntrmass'): kwargs.pop('cntrmass')
if kwargs.has_key('cntrcolors'):
cntrcolors= kwargs['cntrcolors']
kwargs.pop('cntrcolors')
elif contours:
cntrcolors='k'
if kwargs.has_key('cntrlabel') and kwargs['cntrlabel']:
cntrlabel= True
kwargs.pop('cntrlabel')
else:
cntrlabel= False
if kwargs.has_key('cntrlabel'): kwargs.pop('cntrlabel')
if kwargs.has_key('cntrlw'):
cntrlw= kwargs['cntrlw']
kwargs.pop('cntrlw')
elif contours:
cntrlw= None
if kwargs.has_key('cntrls'):
cntrls= kwargs['cntrls']
kwargs.pop('cntrls')
elif contours:
cntrls= None
if kwargs.has_key('cntrlabelsize'):
cntrlabelsize= kwargs['cntrlabelsize']
kwargs.pop('cntrlabelsize')
elif contours:
cntrlabelsize= None
if kwargs.has_key('cntrlabelcolors'):
cntrlabelcolors= kwargs['cntrlabelcolors']
kwargs.pop('cntrlabelcolors')
elif contours:
cntrlabelcolors= None
if kwargs.has_key('cntrinline'):
cntrinline= kwargs['cntrinline']
kwargs.pop('cntrinline')
elif contours:
cntrinline= None
if kwargs.has_key('retCumImage'):
retCumImage= kwargs['retCumImage']
kwargs.pop('retCumImage')
else:
retCumImage= False
if kwargs.has_key('colorbar'):
cb= kwargs['colorbar']
kwargs.pop('colorbar')
else:
cb= False
if kwargs.has_key('shrink'):
shrink= kwargs['shrink']
kwargs.pop('shrink')
else:
shrink= None
if kwargs.has_key('onedhists'):
onedhists= kwargs['onedhists']
kwargs.pop('onedhists')
else:
onedhists= False
if kwargs.has_key('onedhistcolor'):
onedhistcolor= kwargs['onedhistcolor']
kwargs.pop('onedhistcolor')
else:
onedhistcolor= 'k'
if kwargs.has_key('retAxes'):
retAxes= kwargs['retAxes']
kwargs.pop('retAxes')
else:
retAxes= False
if onedhists:
if overplot: fig= pyplot.gcf()
else: fig= pyplot.figure()
nullfmt = NullFormatter() # no labels
# definitions for the axes
left, width = 0.1, 0.65
bottom, height = 0.1, 0.65
bottom_h = left_h = left+width
rect_scatter = [left, bottom, width, height]
rect_histx = [left, bottom_h, width, 0.2]
rect_histy = [left_h, bottom, 0.2, height]
axScatter = pyplot.axes(rect_scatter)
axHistx = pyplot.axes(rect_histx)
axHisty = pyplot.axes(rect_histy)
# no labels
axHistx.xaxis.set_major_formatter(nullfmt)
axHistx.yaxis.set_major_formatter(nullfmt)
axHisty.xaxis.set_major_formatter(nullfmt)
axHisty.yaxis.set_major_formatter(nullfmt)
fig.sca(axScatter)
ax=pyplot.gca()
ax.set_autoscale_on(False)
out= pyplot.imshow(X,extent=extent,**kwargs)
pyplot.axis(extent)
_add_axislabels(xlabel,ylabel)
_add_ticks()
#Add colorbar
if cb:
if shrink is None:
if kwargs.has_key('aspect'):
shrink= sc.amin([float(kwargs['aspect'])*0.87,1.])
else:
shrink= 0.87
CB1= pyplot.colorbar(out,shrink=shrink)
if not zlabel is None:
if zlabel[0] != '$':
thiszlabel=r'$'+zlabel+'$'
else:
thiszlabel=zlabel
CB1.set_label(zlabel)
if contours or retCumImage:
if kwargs.has_key('aspect'):
aspect= kwargs['aspect']
else:
aspect= None
if kwargs.has_key('origin'):
origin= kwargs['origin']
else:
origin= None
if cntrmass:
#Sum from the top down!
X[sc.isnan(X)]= 0.
sortindx= sc.argsort(X.flatten())[::-1]
cumul= sc.cumsum(sc.sort(X.flatten())[::-1])/sc.sum(X.flatten())
cntrThis= sc.zeros(sc.prod(X.shape))
cntrThis[sortindx]= cumul
cntrThis= sc.reshape(cntrThis,X.shape)
else:
cntrThis= X
if contours:
cont= pyplot.contour(cntrThis,levels,colors=cntrcolors,
linewidths=cntrlw,extent=extent,aspect=aspect,
linestyles=cntrls,origin=origin)
if cntrlabel:
pyplot.clabel(cont,fontsize=cntrlabelsize,
colors=cntrlabelcolors,
inline=cntrinline)
if noaxes:
ax.set_axis_off()
#Add onedhists
if not onedhists:
if retCumImage:
return cntrThis
elif retAxes:
return pyplot.gca()
else:
return out
histx= sc.nansum(X.T,axis=1)*m.fabs(ylimits[1]-ylimits[0])/X.shape[1] #nansum bc nan is *no dens value*
histy= sc.nansum(X.T,axis=0)*m.fabs(xlimits[1]-xlimits[0])/X.shape[0]
histx[sc.isnan(histx)]= 0.
histy[sc.isnan(histy)]= 0.
dx= (extent[1]-extent[0])/float(len(histx))
axHistx.plot(sc.linspace(extent[0]+dx,extent[1]-dx,len(histx)),histx,
drawstyle='steps-mid',color=onedhistcolor)
dy= (extent[3]-extent[2])/float(len(histy))
axHisty.plot(histy,sc.linspace(extent[2]+dy,extent[3]-dy,len(histy)),
drawstyle='steps-mid',color=onedhistcolor)
axHistx.set_xlim( axScatter.get_xlim() )
axHisty.set_ylim( axScatter.get_ylim() )
axHistx.set_ylim( 0, 1.2*sc.amax(histx))
axHisty.set_xlim( 0, 1.2*sc.amax(histy))
if retCumImage:
return cntrThis
elif retAxes:
return (axScatter,axHistx,axHisty)
else:
return out
gene_idx = IN['gene_idx'][:].astype('int')
### only keep cancer types where we have at least 100 samples
k_idx = sp.where(ctypes_cnt >= 100)[0]
ctypes_u = ctypes_u[k_idx]
outliers[et] = dict([(x, []) for x in ctypes_u])
chunks = IN['psi'].chunks
for cc, c in enumerate(range(0, IN['psi'].shape[1], chunks[1])):
sys.stdout.write('%i/%i - outliers: %i\n' % (cc, IN['psi'].shape[1] / chunks[1], outlier_cnt))
sys.stdout.flush()
cidx = sp.arange(c, min(c + chunks[1], IN['psi'].shape[1]))
tmp = IN['psi'][:, cidx][widx, :]
tmp_gt = IN_GT['psi'][:, cidx]
gt_dpsi = sp.nanmax(tmp_gt, axis=0) - sp.nanmin(tmp_gt, axis=0)
tmp_tn = tmp[~is_tumor, :]
tn_dpsi = []
for i in range(tmp_tn.shape[1]):
ns_idx = sp.argsort(tmp_tn[:, i])
nnn_idx = ~sp.isnan(tmp_tn[:, i][ns_idx])
if sp.sum(nnn_idx) > 3:
tn_dpsi.append(tmp_tn[:, i][ns_idx][nnn_idx][-2] - tmp_tn[:, i][ns_idx][nnn_idx][1])
else:
tn_dpsi.append(sp.nanmax(tmp_tn[:, i]) - sp.nanmin(tmp_tn[:, i]))
for ct in ctypes_u:
ctidx = sp.where((ctypes == ct) & is_tumor)[0]
cnidx = sp.where((ctypes == ct) & ~is_tumor)[0]
for i in range(tmp.shape[1]):
nnidx = ~sp.isnan(tmp[ctidx, i])
if sp.sum(nnidx) < 80:
def mcdata(data, other=None, x_offset=0, div=2, zero_line=True, events=None,
epochs=None, plot_handle=None, colours=None, title=None,
filename=None, show=True):
"""plot multichanneled data
-> general plot parameter
:type data: ndarray
:param data: The base data to plot with observations(samples) on the rows
and variables(channels) on the columns. This data will be plotted on in
the n topmost axes.
:type other: ndarray
:param other: Other data that augments the base data. The other data will
be plotted in one axe visibly divided from the base data.
Default=None
:type x_offset: int
:param x_offset: A offset value for the x-axis(samples). This allows for
the x-axis to show proper values for windows not starting at x=0. All
values for events and epochs etc. will not be shown if they do not
fall into the frame defined.
Default=0
:type div: float
:param div: Percentage of the figure height to use as divider for the
others plot.
Default=1
:type zero_line: bool
:param zero_line: if True, mark the zero line for the data channels
Default=True
:type events: dict
:param events: dict of events from [x_offset, x_offset+len(data)]. If the
dict entries are lists/ndarrays, vertical markers will be placed at
these samples. If the dict entries are tuples of length 2, like
(ndarray,ndarray), the first is interpreted as the waveform, and the
second as the events. Each unit will be coloured according to the
'colours' vector.
Default={}
:type epochs: dict
:param epochs: dict of epochs from [x_offset, x_offset+len(data)]. Epochs
with numeric keys will be interpreted as belonging to the unit with
that key and will be coloured according to the '' vector. All other
epochs will appear in grey colour. Epochs are passed as a 2dim vector,
like [[start,stop]].
Default={}
"""
# checks
if not isinstance(data, sp.ndarray):
raise ValueError("data is no ndarray!")
if data.ndim != 2:
raise ValueError("data is not dim=2!")
fig, ax = check_plotting_handle(plot_handle, create_ax=False)
# init
fig.clear()
has_other = other is not None
ns, nc = data.shape
x_vals = sp.arange(ns) + x_offset
if colours is None:
col_lst = COLOURS
elif colours == 'black':
col_lst = ['k'] * nc
else:
col_lst = colours
ax_spacer = div * 0.01
# prepare axes
if has_other:
ax_height = (0.8 - (nc + 1) * ax_spacer) / (nc + 1)
else:
ax_height = (0.8 - (nc - 1) * ax_spacer) / nc
for c in xrange(nc):
ax_size = (
0.1, 0.9 - (c + 1) * ax_height - c * ax_spacer, 0.8, ax_height)
ax = fig.add_axes(ax_size, sharex=ax, sharey=ax)
ax.set_ylabel('CH %d' % c)
if c != nc - 1:
plt.setp(ax.get_xticklabels(), visible=False)
#ax.set_xticklabels([tl.get_text() for tl in ax.get_xticklabels()], visible=False)
#ax.set_xlim(x_vals[0], x_vals[-1])
#ax.set_ylim(data.min() * 1.1, data.max() * 1.1)
if has_other:
ax = fig.add_axes((0.1, 0.1, 0.8, ax_height), sharex=ax)
ax.set_ylabel('OTHER')
#ax.set_xlim(x_vals[0], x_vals[-1])
#ax.set_ylim(-other.max() * 1.1, other.max() * 1.1)
# plot data
for c, a in enumerate(fig.axes[:nc]):
a.add_collection(
mpl.collections.LineCollection(
[sp.vstack((x_vals, data[:, c])).T], colors=[(0, 0, 0)]))
# plot other
if has_other:
fig.axes[-1].add_collection(mpl.collections.LineCollection(
[sp.vstack((x_vals, other[:, c])).T for c in
xrange(other.shape[1])], colors=col_lst))
# plot events
if events is not None:
for u in sorted(events):
try:
col = col_lst[u % len(col_lst)]
except:
col = 'gray'
if isinstance(events[u], tuple):
if len(events[u]) != 2:
raise ValueError('Event entry for unit %s is not a tuple '
'of length 2' % u)
u_wf, u_ev = events[u]
if not u_wf.shape[1] == nc:
raise ValueError('Waveform for unit %s has mismatching '
'channel count' % u)
cut = int(sp.floor(u_wf.shape[0] / 2.0))
for c, a in enumerate(fig.axes[:nc]):
a.add_collection(
mpl.collections.LineCollection(
[sp.vstack((sp.arange(u_wf.shape[0]) - cut + u_ev[i],
u_wf[:, c])).T
for i in xrange(u_ev.size)], colors=[col]))
if has_other:
for e in u_ev:
fig.axes[-1].axvline(e, c=col)
elif isinstance(events[u], (list, sp.ndarray)):
for a in fig.axes:
for e in events[u]:
a.axvline(e, c=col)
else:
raise ValueError('events for unit %s are messed up' % u)
# plot epochs
if epochs is not None:
for u in sorted(epochs):
try:
col = col_lst[u % len(col_lst)]
except:
col = 'gray'
for ep in epochs[u]:
for a in fig.axes:
a.axvspan(ep[0], ep[1], fc=col, alpha=0.2)
# zero lines
if zero_line:
for a in fig.axes:
a.add_collection(
mpl.collections.LineCollection(
[sp.vstack(([x_vals[0], x_vals[-1]], sp.zeros(2))).T],
linestyles='dashed',
colors=[(0, 0, 0)]))
# scale axes
fig.axes[0].set_xlim(x_vals[0], x_vals[-1])
fig.axes[0].set_ylim(sp.nanmin(data) * 1.05, sp.nanmax(data) * 1.05)
if has_other:
fig.axes[-1].set_ylim(sp.nanmin(other) * 1.1, sp.nanmax(other) * 1.1)
# figure title
if title is not None:
fig.suptitle(title)
# produce plot
if filename is not None:
save_figure(fig, filename, '')
if show is True:
plt.show()
# return
return fig
tmp_psi_ = hdf5_handles[t]['psi'][:, tmp_idx]
tmp_iso1 = hdf5_handles[t]['iso1'][:,
tmp_idx] * sf[t][:,
sp.newaxis]
tmp_iso2 = hdf5_handles[t]['iso2'][:,
tmp_idx] * sf[t][:,
sp.newaxis]
for mr in mr_t:
for i, p in enumerate(tissues):
tmp_psi = tmp_psi_[t_idx[(t, p)], :]
n_idx = sp.c_[tmp_iso1[t_idx[(t, p)], :].max(axis=0),
tmp_iso2[t_idx[(t, p)], :].max(
axis=0)].min(axis=1) < mr
tmp_psi[:, n_idx] = sp.nan
idx_nn = ~sp.isnan(tmp_psi)
d_psi = sp.nanmax(tmp_psi, axis=0) - sp.nanmin(tmp_psi,
axis=0)
d_psi[sp.isnan(d_psi)] = 0
for dp in d_psi_t:
if cc == 0:
count[(t, p)][(mr, dp)] = tmp_idx[
(sp.sum(idx_nn, axis=0) >= nan_t)
& (d_psi >= dp)]
else:
count[(t, p)][(mr, dp)] = sp.r_[
count[(t, p)][(mr, dp)],
tmp_idx[(sp.sum(idx_nn, axis=0) >= nan_t)
& (d_psi >= dp)]]
### store count as pre-processed pickle
cPickle.dump((count, tissues, dsets, tids, is_tumor, t_idx),
open(count_pickle, 'w'), -1)
def contourGD(geod,axstr,slicenum,vbounds=None,time = 0,gkey = None,cmap=defmap,
fig=None,ax=None,title='',cbar=True,m=None,levels=None):
""" """
poscoords = ['cartesian','wgs84','enu','ecef']
assert geod.coordnames.lower() in poscoords
if geod.coordnames.lower() in ['cartesian','enu','ecef']:
axdict = {'x':0,'y':1,'z':2}
veckeys = ['x','y','z']
elif geod.coordnames.lower() == 'wgs84':
axdict = {'lat':0,'long':1,'alt':2}# shows which row is this coordinate
veckeys = ['long','lat','alt']# shows which is the x, y and z axes for plotting
if type(axstr)==str:
axis=axstr
else:
axis= veckeys[axstr]
veckeys.remove(axis.lower())
veckeys.append(axis.lower())
datacoords = geod.dataloc
xyzvecs = {l:sp.unique(datacoords[:,axdict[l]]) for l in veckeys}
#make matrices
M1,M2 = sp.meshgrid(xyzvecs[veckeys[0]],xyzvecs[veckeys[1]])
slicevec = sp.unique(datacoords[:,axdict[axis]])
min_idx = sp.argmin(sp.absolute(slicevec-slicenum))
slicenum=slicevec[min_idx]
rec_coords = {axdict[veckeys[0]]:M1.flatten(),axdict[veckeys[1]]:M2.flatten(),
axdict[axis]:slicenum*sp.ones(M2.size)}
new_coords = sp.zeros((M1.size,3))
#make coordinates
for ckey in rec_coords.keys():
new_coords[:,ckey] = rec_coords[ckey]
#determine the data name
if gkey is None:
gkey = geod.data.keys[0]
# get the data location, first check if the data can be just reshaped then do a
# search
sliceindx = slicenum==datacoords[:,axdict[axis]]
datacoordred = datacoords[sliceindx]
rstypes = ['C','F','A']
nfounds = True
M1dlfl = datacoordred[:,axdict[veckeys[0]]]
M2dlfl = datacoordred[:,axdict[veckeys[1]]]
for ir in rstypes:
M1dl = sp.reshape(M1dlfl,M1.shape,order =ir)
M2dl = sp.reshape(M2dlfl,M1.shape,order =ir)
if sp.logical_and(sp.allclose(M1dl,M1),sp.allclose(M2dl,M2)):
nfounds=False
break
if nfounds:
dataout = geod.datareducelocation(new_coords,geod.coordnames,gkey)[:,time]
dataout = sp.reshape(dataout,M1.shape)
else:
dataout = sp.reshape(geod.data[gkey][sliceindx,time],M1.shape,order=ir)
title = insertinfo(title,gkey,geod.times[time,0],geod.times[time,1])
if (ax is None) and (fig is None):
fig = plt.figure(facecolor='white')
ax = fig.gca()
elif ax is None:
ax = fig.gca()
if vbounds is None:
vbounds=[sp.nanmin(dataout),sp.nanmax(dataout)]
if levels is None:
levels=sp.linspace(vbounds[0],vbounds[1],5)
if m is None:
ploth = ax.contour(M1,M2,dataout,levels = levels,vmin=vbounds[0], vmax=vbounds[1],cmap = cmap)
ax.axis([xyzvecs[veckeys[0]].min(), xyzvecs[veckeys[0]].max(),
xyzvecs[veckeys[1]].min(), xyzvecs[veckeys[1]].max()])
if cbar:
cbar2 = plt.colorbar(ploth, ax=ax, format='%.0e')
else:
cbar2 = None
ax.set_title(title)
ax.set_xlabel(veckeys[0])
ax.set_ylabel(veckeys[1])
else:
N1,N2 = m(M1,M2)
ploth = ax.contour(N1,N2,dataout,levels = levels,vmin=vbounds[0], vmax=vbounds[1],cmap = cmap)
if cbar:
#cbar2 = m.colorbar(ploth, format='%.0e')
cbar2 = m.colorbar(ploth)
else:
cbar2 = None
return(ploth,cbar2)
def bovy_dens2d(X, **kwargs):
"""
NAME:
bovy_dens2d
PURPOSE:
plot a 2d density with optional contours
INPUT:
first argument is the density
matplotlib.pyplot.imshow keywords (see http://matplotlib.sourceforge.net/api/axes_api.html#matplotlib.axes.Axes.imshow)
xlabel - (raw string!) x-axis label, LaTeX math mode, no $s needed
ylabel - (raw string!) y-axis label, LaTeX math mode, no $s needed
xrange
yrange
noaxes - don't plot any axes
overplot - if True, overplot
colorbar - if True, add colorbar
shrink= colorbar argument: shrink the colorbar by the factor (optional)
conditional - normalize each column separately (for probability densities, i.e., cntrmass=True)
gcf=True does not start a new figure (does change the ranges and labels)
Contours:
justcontours - if True, only draw contours
contours - if True, draw contours (10 by default)
levels - contour-levels
cntrmass - if True, the density is a probability and the levels are probability masses contained within the contour
cntrcolors - colors for contours (single color or array)
cntrlabel - label the contours
cntrlw, cntrls - linewidths and linestyles for contour
cntrlabelsize, cntrlabelcolors,cntrinline - contour arguments
cntrSmooth - use ndimage.gaussian_filter to smooth before contouring
onedhists - if True, make one-d histograms on the sides
onedhistcolor - histogram color
retAxes= return all Axes instances
retCont= return the contour instance
OUTPUT:
plot to output device, Axes instances depending on input
HISTORY:
2010-03-09 - Written - Bovy (NYU)
"""
overplot = kwargs.pop('overplot', False)
gcf = kwargs.pop('gcf', False)
if not overplot and not gcf:
pyplot.figure()
xlabel = kwargs.pop('xlabel', None)
ylabel = kwargs.pop('ylabel', None)
zlabel = kwargs.pop('zlabel', None)
if 'extent' in kwargs:
extent = kwargs.pop('extent')
else:
xlimits = kwargs.pop('xrange', [0, X.shape[1]])
ylimits = kwargs.pop('yrange', [0, X.shape[0]])
extent = xlimits + ylimits
if not 'aspect' in kwargs:
kwargs['aspect'] = (xlimits[1] - xlimits[0]) / float(ylimits[1] -
ylimits[0])
noaxes = kwargs.pop('noaxes', False)
justcontours = kwargs.pop('justcontours', False)
if ('contours' in kwargs and kwargs['contours']) or \
'levels' in kwargs or justcontours or \
('cntrmass' in kwargs and kwargs['cntrmass']):
contours = True
else:
contours = False
kwargs.pop('contours', None)
if 'levels' in kwargs:
levels = kwargs['levels']
kwargs.pop('levels')
elif contours:
if 'cntrmass' in kwargs and kwargs['cntrmass']:
levels = sc.linspace(0., 1., _DEFAULTNCNTR)
elif True in sc.isnan(sc.array(X)):
levels = sc.linspace(sc.nanmin(X), sc.nanmax(X), _DEFAULTNCNTR)
else:
levels = sc.linspace(sc.amin(X), sc.amax(X), _DEFAULTNCNTR)
cntrmass = kwargs.pop('cntrmass', False)
conditional = kwargs.pop('conditional', False)
cntrcolors = kwargs.pop('cntrcolors', 'k')
cntrlabel = kwargs.pop('cntrlabel', False)
cntrlw = kwargs.pop('cntrlw', None)
cntrls = kwargs.pop('cntrls', None)
cntrSmooth = kwargs.pop('cntrSmooth', None)
cntrlabelsize = kwargs.pop('cntrlabelsize', None)
cntrlabelcolors = kwargs.pop('cntrlabelcolors', None)
cntrinline = kwargs.pop('cntrinline', None)
retCumImage = kwargs.pop('retCumImage', False)
cb = kwargs.pop('colorbar', False)
shrink = kwargs.pop('shrink', None)
onedhists = kwargs.pop('onedhists', False)
onedhistcolor = kwargs.pop('onedhistcolor', 'k')
retAxes = kwargs.pop('retAxes', False)
retCont = kwargs.pop('retCont', False)
if onedhists:
if overplot or gcf: fig = pyplot.gcf()
else: fig = pyplot.figure()
nullfmt = NullFormatter() # no labels
# definitions for the axes
left, width = 0.1, 0.65
bottom, height = 0.1, 0.65
bottom_h = left_h = left + width
rect_scatter = [left, bottom, width, height]
rect_histx = [left, bottom_h, width, 0.2]
rect_histy = [left_h, bottom, 0.2, height]
axScatter = pyplot.axes(rect_scatter)
axHistx = pyplot.axes(rect_histx)
axHisty = pyplot.axes(rect_histy)
# no labels
axHistx.xaxis.set_major_formatter(nullfmt)
axHistx.yaxis.set_major_formatter(nullfmt)
axHisty.xaxis.set_major_formatter(nullfmt)
axHisty.yaxis.set_major_formatter(nullfmt)
fig.sca(axScatter)
ax = pyplot.gca()
ax.set_autoscale_on(False)
if conditional:
plotthis = X / sc.tile(sc.sum(X, axis=0), (X.shape[1], 1))
else:
plotthis = X
if not justcontours:
out = pyplot.imshow(plotthis, extent=extent, **kwargs)
if not overplot:
pyplot.axis(extent)
_add_axislabels(xlabel, ylabel)
_add_ticks()
#Add colorbar
if cb and not justcontours:
if shrink is None:
shrink = sc.amin([float(kwargs.pop('aspect', 1.)) * 0.87, 1.])
CB1 = pyplot.colorbar(out, shrink=shrink)
if not zlabel is None:
if zlabel[0] != '$':
thiszlabel = r'$' + zlabel + '$'
else:
thiszlabel = zlabel
CB1.set_label(thiszlabel)
if contours or retCumImage:
aspect = kwargs.get('aspect', None)
origin = kwargs.get('origin', None)
if cntrmass:
#Sum from the top down!
plotthis[sc.isnan(plotthis)] = 0.
sortindx = sc.argsort(plotthis.flatten())[::-1]
cumul = sc.cumsum(sc.sort(plotthis.flatten())[::-1]) / sc.sum(
plotthis.flatten())
cntrThis = sc.zeros(sc.prod(plotthis.shape))
cntrThis[sortindx] = cumul
cntrThis = sc.reshape(cntrThis, plotthis.shape)
else:
cntrThis = plotthis
if contours:
if not cntrSmooth is None:
cntrThis = ndimage.gaussian_filter(cntrThis,
cntrSmooth,
mode='nearest')
cont = pyplot.contour(cntrThis,
levels,
colors=cntrcolors,
linewidths=cntrlw,
extent=extent,
aspect=aspect,
linestyles=cntrls,
origin=origin)
if cntrlabel:
pyplot.clabel(cont,
fontsize=cntrlabelsize,
colors=cntrlabelcolors,
inline=cntrinline)
if noaxes:
ax.set_axis_off()
#Add onedhists
if not onedhists:
if retCumImage:
return cntrThis
elif retAxes:
return pyplot.gca()
elif retCont:
return cont
elif justcontours:
return cntrThis
else:
return out
histx = sc.nansum(X.T, axis=1) * m.fabs(ylimits[1] - ylimits[0]) / X.shape[
1] #nansum bc nan is *no dens value*
histy = sc.nansum(X.T,
axis=0) * m.fabs(xlimits[1] - xlimits[0]) / X.shape[0]
histx[sc.isnan(histx)] = 0.
histy[sc.isnan(histy)] = 0.
dx = (extent[1] - extent[0]) / float(len(histx))
axHistx.plot(sc.linspace(extent[0] + dx, extent[1] - dx, len(histx)),
histx,
drawstyle='steps-mid',
color=onedhistcolor)
dy = (extent[3] - extent[2]) / float(len(histy))
axHisty.plot(histy,
sc.linspace(extent[2] + dy, extent[3] - dy, len(histy)),
drawstyle='steps-mid',
color=onedhistcolor)
axHistx.set_xlim(axScatter.get_xlim())
axHisty.set_ylim(axScatter.get_ylim())
axHistx.set_ylim(0, 1.2 * sc.amax(histx))
axHisty.set_xlim(0, 1.2 * sc.amax(histy))
if retCumImage:
return cntrThis
elif retAxes:
return (axScatter, axHistx, axHisty)
elif justcontours:
return cntrThis
else:
return out
def plotSIF2(num=1e-4):
a = eqtools.EqdskReader(gfile='/afs/ipp-garching.mpg.de/home/i/ianf/codes/python/general/g33669.3000')
a.remapLCFS()
b = eqtools.AUGDDData(33669)
tok = TRIPPy.Tokamak(b)
cont = (pow(scipy.linspace(0,1,11),2)*(a.getFluxLCFS()-a.getFluxAxis())+a.getFluxAxis())
print(a.getFluxAxis())
print(a.getFluxLCFS())
print(cont)
temp = b.getMachineCrossSectionFull()
plotEq.plot(a,33669,lims=temp,contours=-1*cont[[0,10]],alpha=.15)
ray = genSIF(tok)
print(ray.norm.s)
#inp = scipy.linspace(ray.norm.s[-2],ray.norm.s[-1],num)
inp = scipy.mgrid[ray.norm.s[-2]:ray.norm.s[-1]:num]
r = ray(inp).r()[0]
z = ray(inp).r()[2]
l = inp - inp[0]
print(r.shape,z.shape,l.shape)
plt.plot(r,z,color='#228B22',linewidth=2.)
plt.subplots_adjust(left=.2,right=.95)
plt.gca().set_xlim([scipy.nanmin(temp[0].astype(float)),scipy.nanmax(temp[0].astype(float))])
plt.gca().set_ylim([scipy.nanmin(temp[1].astype(float)),scipy.nanmax(temp[1].astype(float))])
limy = plt.gca().get_ylim()
limx = plt.gca().get_xlim()
plt.gca().text(1.0075*(limx[1]-limx[0])+limx[0],.97*(limy[1]-limy[0])+limy[0],str(33669),rotation=90,fontsize=14)
ax1 = plt.gca()
ax1.arrow(1.8,-.608,.025,0.0,head_width=.05,head_length=.1,fc='k',ec='k',zorder=10)
ax1.arrow(1.8,0.728,.025,0.0,head_width=.05,head_length=.1,fc='k',ec='k',zorder=10)
iax = plt.axes([0,0,1,1])
x0 = (r.min()-limx[0])/(limx[1]-limx[0])
y0 = (z.min()-limy[0])/(limy[1]-limy[0])
y1 = (z.max()-limy[0])/(limy[1]-limy[0])
print(limx)
print(limy)
print([x0+.05,y0,.2,y1-y0])
ip = InsetPosition(ax1, [x0+.1,y0,.3,y1-y0])
#ip = plt.axes([.05,.05,.02,.02])
iax.set_axes_locator(ip)
tempData = scipy.squeeze(GIWprofiles.te(b.rz2psinorm(r,z,[3.0],sqrt=True,each_t=True),4e3,1e3))
print(tempData.shape)
iax.semilogx(tempData,l,color='#0E525A',linewidth=2.)
iax.set_ylim(l.max(),l.min())
iax.set_xlim(1e2,1e4)
iax.set_xlabel('$T_e$ [eV]')
iax.text(2e2,1.0,'$l(T_e)$')
iax.yaxis.tick_right()
iax.set_axis_bgcolor('#eaeaea')
