def fixticks(current_data):
from pylab import ticklabel_format, plot,grid,ones,sqrt, \
legend,title,ylabel,text
ticklabel_format(useOffset=False)
# to plot max elevation over entire computation:
#if xmax is not None:
# plot(xmax, etamax, 'r')
#grid(True)
hl = 3200.
hr = 200.
greens = (hl / hr)**(0.25)
print('greens = ', greens)
#plot(current_data.x, greens*ones(current_data.x.shape),'g--')
plot(xlimits, [greens, greens], 'g--', label='$C_g$, Greens Law')
ctrans = 2 * sqrt(hl) / (sqrt(hl) + sqrt(hr))
crefl = (sqrt(hl) - sqrt(hr)) / (sqrt(hl) + sqrt(hr))
print('ctrans = ', ctrans)
plot(xlimits, [ctrans, ctrans],
'r--',
label='$C_T$, Transmission coefficient')
legend(loc='upper left')
title('')
ylabel('meters', fontsize=14)
if current_data.frameno == 0:
text(-80, -0.4, '$\longrightarrow$', fontsize=20)
text(-80, -0.6, 'Incident')
h = current_data.q[0, :]
mx2 = int(round(len(h) / 2.))
etamax2 = (h[:mx2] - hl).max()
print('mx2 = %i, etamax2 = %g' % (mx2, etamax2))
def plot_xy():
plt.plot(x, y, 'bo')
plt.ticklabel_format(useOffset=False)
plt.xlabel('JD')
plt.ylabel('Number of files')
plt.title('Number of files with search string *xx*HH*uvc')
plt.show()
def plotCumulativeRegretsFromDump(names, envName, median, quantile1, quantile2,
times, timeHorizon):
nbFigure = pl.gcf().number + 1
pl.figure(nbFigure)
textfile = "results/Regret-"
colors = [
'black', 'blue', 'gray', 'green', 'red'
] # ['black', 'purple', 'blue','cyan','yellow', 'orange', 'red', 'chocolate']
style = ['o', 'v', 's', 'd', '<']
for i in range(len(median)):
pl.plot(times,
median[i],
style[i],
label=names[i],
color=colors[i % len(colors)],
linewidth=2.0,
linestyle='--',
markevery=0.05)
pl.plot(times,
quantile1[i],
color=colors[i % len(colors)],
linestyle=':',
linewidth=0.7)
pl.plot(times,
quantile2[i],
color=colors[i % len(colors)],
linestyle=':',
linewidth=0.7)
textfile += names[i] + "-"
print(names[i], ' has regret ', median[i][-1], ' after ', timeHorizon,
' time steps with quantiles ', quantile1[i][-1], ' and ',
quantile2[i][-1])
textfile += "_" + str(timeHorizon) + "_" + envName
pl.legend(loc=2)
pl.xlabel("Time steps", fontsize=13, fontname="Arial")
pl.ylabel("Regret", fontsize=13, fontname="Arial")
#pl.xticks(times)
pl.ticklabel_format(axis='both',
useMathText=True,
useOffset=True,
style='sci',
scilimits=(0, 0))
pl.ylim(0)
pl.savefig(textfile + '.png')
pl.savefig(textfile + '.pdf')
pl.xscale('log')
pl.savefig(textfile + '_xlog.png')
pl.savefig(textfile + '_xlog.pdf')
pl.ylim(100)
if (timeHorizon > 1000):
pl.xlim(1000, timeHorizon)
pl.xscale('linear')
pl.yscale('log')
pl.savefig(textfile + '_ylog.png')
pl.savefig(textfile + '_ylog.pdf')
pl.xscale('log')
pl.savefig(textfile + '_loglog.png')
pl.savefig(textfile + '_loglog.pdf')
def aa(current_data):
from pylab import ticklabel_format, xticks, gca, cos, pi, savefig
title_hours(current_data)
ticklabel_format(format='plain', useOffset=False)
xticks(rotation=20)
a = gca()
a.set_aspect(1. / cos(46.349 * pi / 180.))
def evaluate_models_on_testing(x, y, models):
"""
For each regression model, compute the RMSE for this model and plot the
test data along with the model’s estimation.
For the plots, you should plot data points (x,y) as blue dots and your best
fit curve (aka model) as a red solid line. You should also label the axes
of this figure appropriately and have a title reporting the following
information:
degree of your regression model,
RMSE of your model evaluated on the given data points.
Args:
x: an 1-d pylab array with length N, representing the x-coordinates of
the N sample points
y: an 1-d pylab array with length N, representing the y-coordinates of
the N sample points
models: a list containing the regression models you want to apply to
your data. Each model is a pylab array storing the coefficients of
a polynomial.
Returns:
None
"""
for model in models:
modeldata = pylab.polyval(model, x)
pylab.plot(x, y, 'bo', label='Historical Data')
pylab.plot(x, modeldata, 'r-', label='Prediction')
pylab.xlabel('Year')
pylab.ticklabel_format(useOffset=False)
pylab.ylabel('Temp')
pylab.show()
def plotResults(dataTCT, current, corr_curr):
i = 0
diff = []
while i < len(current):
diff.append(corr_curr[i] - current[i])
i += 1
fig = pylab.figure(1, (8, 7))
pylab.plot(dataTCT.xdata[dataTCT.initPoint:dataTCT.endPoint - 700],
current[0:len(current) - 700],
"r",
label="Current")
pylab.plot(dataTCT.xdata[dataTCT.initPoint:dataTCT.endPoint - 700],
corr_curr[0:len(corr_curr) - 700],
"k",
label="Corrected Current")
pylab.plot(dataTCT.xdata[dataTCT.initPoint:dataTCT.endPoint - 700],
diff[0:len(diff) - 700],
"b",
label="Difference")
pylab.ticklabel_format(axis='both', style='sci', scilimits=(0, 0))
pylab.legend(loc=0)
pylab.grid(True)
pylab.xlabel("Time(s)")
pylab.ylabel("Voltage(V) ")
pylab.tight_layout()
pylab.savefig(dataTCT.filename.replace(".bin", ".png"))
pylab.close()
def plotTotResults(
filename_tot,
xdata_tot,
current_tot,
init_tot,
end_tot,
):
fig = pylab.figure(1, (8, 7))
n = 0
voltage = []
while n <= 100:
voltage.append(n * 10)
n += 1
i = 1
while i < len(current_tot):
print str(init_tot[i] - end_tot[i])
print len(current_tot[i])
pylab.plot(xdata_tot[i][init_tot[i]:end_tot[i] - 800],
current_tot[i][0:len(current_tot[i]) - 800],
label=str(voltage[i]) + " V")
i += 10
pylab.ticklabel_format(axis='both', style='sci', scilimits=(0, 0))
pylab.legend(loc=0)
pylab.grid(True)
pylab.xlabel("Time")
pylab.ylabel("Current")
pylab.tight_layout()
pylab.savefig("CurrentCombine.png")
pylab.close()
def plotdata( xdata, ydata, cont ): pylab.plot( xdata, ydata, "-", label = "waveform" + str( cont ) ) pylab.ticklabel_format( style = 'sci', scilimits = ( 0, 0 ) ) pylab.xlabel( "Time [s]" ) pylab.ylabel( "Signal [V]" ) pylab.legend( loc = 1 ) pylab.grid()
def cpu(*F,N=(500,5000,500)):
'''Mostra gráfico com o consumo de tempo das funções *F, para
entradas com tamanho variando no intervalo N=(500,5000,500).
Um parâmetro E = g define a função que gera as entradas'''
C = ['r','b','g','c','m','y','k','w']
M = ['o','s','p','h','+','x','v','^']
X = []
Y = [[] for _ in range(len(F))]
print('n = ',end='')
inicio = time()
rodada = 1
for n in range(N[0],N[1]+1,N[2]):
print('%s ' % rodada,end='')
X.append(n)
v = sample(range(0,n),n)
for i,f in enumerate(F):
w = deepcopy(v)
Y[i].append(tempo(f,w))
rodada += 1
print('\nTempo total: %.1fs' % (time()-inicio))
xlabel('tamanho da entrada')
ylabel('tempo de execução (s)')
ticklabel_format(style='sci', axis='both', scilimits=(-3,+4))
grid(True)
for i,f in enumerate(F):
plot(X,Y[i],color=C[i%len(C)],marker=M[i%len(M)],label=f.__name__)
legend(loc='upper left')
show()
def fixticks(current_data):
from pylab import ticklabel_format, plot,grid,ones,sqrt,\
where,tight_layout,legend,nan, title
ticklabel_format(format='plain', useOffset=False)
# to plot max elevation over entire computation:
if xmax is not None:
plot(xmax, etamax, 'r', label='wave height')
grid(True)
hl = 3000.
hr = 100.
greens = (hl / hr)**(0.25)
print('greens = ', greens)
z = current_data.q[0, :] - current_data.q[2, :]
z = where(z > 10, z, 10.)
xp = mapc2p(current_data.x)
plot(xp, (hl / z)**(0.25), 'g--', label='CG')
ctrans = 2 * sqrt(hl) / (sqrt(hl) + sqrt(hr))
crefl = (sqrt(hl) - sqrt(hr)) / (sqrt(hl) + sqrt(hr))
print('ctrans = ', ctrans)
print('crefl = ', crefl)
hm = 1400.
ct12 = 2 * sqrt(hl) / (sqrt(hl) +
sqrt(hm)) * 2 * sqrt(hm) / (sqrt(hm) + sqrt(hr))
plot([-60e3, 0], [ct12, ct12], 'r--', label='CT1*CT2')
ctx = 2 * sqrt(hl) / (sqrt(hl) + sqrt(z))
plot(xp, ctx, 'b--', label='CT')
legend(loc='upper left', fontsize=8, framealpha=1)
#tight_layout()
timestr = timeformat(current_data.t)
title('Surface displacement at time %s' % timestr)
def aa_patches(current_data):
from pylab import ticklabel_format, xticks, gca, cos, pi, yticks
ticklabel_format(format='plain',useOffset=False)
xticks([180, 200, 220, 240], rotation=20, fontsize = 28)
yticks(fontsize = 28)
a = gca()
a.set_aspect(1./cos(41.75*pi/180.))
def plotCumulativeRegrets(names,
cumulativerewards_,
timeHorizon,
testName="riverSwim",
semilog=False,
ysemilog=False):
#print(len(cumulativerewards_[0]), len(cumulativerewards_))#[0])#print(len(cumulativerewards_[0]), cumulativerewards_[0])
nbFigure = pl.gcf().number + 1
pl.figure(nbFigure)
cur_dir = os.path.abspath(os.path.curdir)
output_path = os.path.join(cur_dir, 'results')
textfile = output_path + "/Regret-"
colors = [
'black', 'blue', 'gray', 'green', 'red'
] #['black', 'purple', 'blue','cyan','yellow', 'orange', 'red', 'chocolate']
avgcum_rs = [
np.mean(cumulativerewards_[-1], axis=0) -
np.mean(cumulativerewards_[i], axis=0)
for i in range(len(cumulativerewards_) - 1)
]
std_cum_rs = [
1.96 * np.std(cumulativerewards_[i], axis=0) /
np.sqrt(len(cumulativerewards_[i]))
for i in range(len(cumulativerewards_) - 1)
]
for i in range(len(cumulativerewards_) - 1):
pl.plot(avgcum_rs[i], label=names[i], color=colors[i % len(colors)])
step = timeHorizon // 10
pl.errorbar(np.arange(0, timeHorizon, step),
avgcum_rs[i][0:timeHorizon:step],
std_cum_rs[i][0:timeHorizon:step],
color=colors[i % len(colors)],
linestyle='None',
capsize=10)
textfile += names[i] + "-"
print(names[i], ' has regret ', avgcum_rs[i][-1], ' after ',
len(avgcum_rs[i]), ' time steps with variance ',
std_cum_rs[i][-1])
#pl.show()
pl.legend()
pl.xlabel("Time steps", fontsize=13, fontname="Arial")
pl.ylabel("Regret", fontsize=13, fontname="Arial")
pl.ticklabel_format(axis='both',
useMathText=True,
useOffset=True,
style='sci',
scilimits=(0, 0))
if semilog:
pl.xscale('log')
textfile += "_xsemilog"
else:
pl.xlim(0, timeHorizon)
if ysemilog:
pl.yscale('log')
textfile += "_ysemilog"
pl.ylim(100)
else:
pl.ylim(0)
pl.savefig(textfile + testName + '.png')
def test_verify_AIS(self):
model = oRBM(input_size=self.input_size,
hidden_size=self.hidden_size,
beta=self.beta)
model.W.set_value(self.W)
model.b.set_value(self.b)
model.c.set_value(self.c)
# Brute force
print "Computing lnZ using brute force (i.e. summing the free energy of all posible $v$)..."
V = theano.shared(
value=cartesian([(0, 1)] * self.input_size, dtype=config.floatX))
brute_force_lnZ = logsumexp(-model.free_energy(V), 0)
f_brute_force_lnZ = theano.function([], brute_force_lnZ)
params_bak = [param.get_value() for param in model.parameters]
print "Approximating lnZ using AIS..."
import time
start = time.time()
try:
ais_working_dir = tempfile.mkdtemp()
result = compute_AIS(model,
M=self.nb_samples,
betas=self.betas,
seed=1234,
ais_working_dir=ais_working_dir,
force=True)
logcummean_Z, logcumstd_Z_down, logcumstd_Z_up = result[
'logcummean_Z'], result['logcumstd_Z_down'], result[
'logcumstd_Z_up']
std_lnZ = result['std_lnZ']
print "{0} sec".format(time.time() - start)
import pylab as plt
plt.gca().set_xmargin(0.1)
plt.errorbar(range(1, self.nb_samples + 1),
logcummean_Z,
yerr=[std_lnZ, std_lnZ],
fmt='or')
plt.errorbar(range(1, self.nb_samples + 1),
logcummean_Z,
yerr=[logcumstd_Z_down, logcumstd_Z_up],
fmt='ob')
plt.plot([1, self.nb_samples], [f_brute_force_lnZ()] * 2, '--g')
plt.ticklabel_format(useOffset=False, axis='y')
plt.show()
AIS_logZ = logcummean_Z[-1]
assert_array_equal(params_bak[0], model.W.get_value())
assert_array_equal(params_bak[1], model.b.get_value())
assert_array_equal(params_bak[2], model.c.get_value())
print np.abs(AIS_logZ - f_brute_force_lnZ())
assert_almost_equal(AIS_logZ, f_brute_force_lnZ(), decimal=2)
finally:
shutil.rmtree(ais_working_dir)
def X1plot():
sns.set(font_scale=1.5)
pl.figure(figsize=(12, 6))
pl.subplot(1, 2, 1)
w, X = np.loadtxt("X1DZ1re.dat").T
pl.plot(w, X)
w, X = np.loadtxt("X1DZ1im.dat").T
pl.plot(w, X)
pl.xlim([0.85e-3, 1.1e-3])
pl.xlabel(r"$\omega$")
pl.ylabel(r"$\chi(\omega)$")
pl.ticklabel_format(style='sci', scilimits=(0, 0))
pl.subplot(1, 2, 2)
w, X = np.loadtxt("X1DZ3re.dat").T
pl.plot(w, X)
w, X = np.loadtxt("X1DZ3im.dat").T
pl.plot(w, X)
pl.xlim([9.694658e-4, 9.694661e-4])
pl.xlabel(r"$\omega$")
pl.ylabel(r"$\chi(\omega)$")
pl.ticklabel_format(style='sci', scilimits=(0, 0))
pl.tight_layout()
pl.savefig("X1.pdf")
pl.show()
def plotraw(self):
"""quickly plots the raw isotope pattern (with mass defects preserved)"""
import pylab as pl
pl.bar(self.rawip[0], self.rawip[1], width=0.0001)
pl.xlabel('m/z', style='italic')
pl.ylabel('normalized intensity')
pl.ticklabel_format(useOffset=False)
pl.show()
def plot_I(susceptible, infected, Title):
pl.figure(figsize=(5,3))
pl.plot(time, infected,label="Infected", color=(0.8666666666666667, 0.5176470588235295, 0.3215686274509804))
pl.fill_between(time, infected, 0, alpha=0.30, color=(0.8666666666666667, 0.5176470588235295, 0.3215686274509804))
pl.ticklabel_format(axis="y", style="sci", scilimits=(0,0))
pl.xlabel('Time in days', fontsize=14)
pl.ylabel('Infected individuals', fontsize=14)
pl.title(Title)
def plotraw(self):
"""quickly plots the raw isotope pattern (with mass defects preserved)"""
import pylab as pl
pl.bar(self.rawip[0],self.rawip[1],width=0.0001)
pl.xlabel('m/z', style='italic')
pl.ylabel('normalized intensity')
pl.ticklabel_format(useOffset=False)
pl.show()
def aa(current_data):
from pylab import ticklabel_format, xticks, gca, cos, pi
plotcc(current_data)
title_hours(current_data)
ticklabel_format(format='plain',useOffset=False)
xticks(rotation=20)
a = gca()
a.set_aspect(1./cos(41.75*pi/180.))
def aa(current_data):
from pylab import ticklabel_format, xticks, gca, cos, pi, savefig
title_hours(current_data)
ticklabel_format(format="plain", useOffset=False)
xticks(rotation=20)
a = gca()
a.set_aspect(1.0 / cos(46.349 * pi / 180.0))
def plotbar(self):
"""quickly plots a bar plot of the isotope bar pattern"""
import pylab as pl
fwhm = self.em / self.ks['res']
pl.bar(self.barip[0], self.barip[1], width=fwhm, align='center')
pl.xlabel('m/z', style='italic')
pl.ylabel('normalized intensity')
pl.ticklabel_format(useOffset=False)
pl.show()
def fixup(current_data):
import pylab
#addgauges(current_data)
t = current_data.t
t = t / 3600. # hours
pylab.title('Surface at %4.2f hours' % t, fontsize=20)
pylab.ticklabel_format(format='plain',useOffset=False)
mean_lat = 19.7
pylab.gca().set_aspect(1.0 / pylab.cos(pylab.pi / 180.0 * mean_lat))
def plotbar(self):
"""quickly plots a bar plot of the isotope bar pattern"""
import pylab as pl
fwhm = self.em/self.ks['res']
pl.bar(self.barip[0], self.barip[1], width=fwhm, align='center')
pl.xlabel('m/z', style='italic')
pl.ylabel('normalized intensity')
pl.ticklabel_format(useOffset=False)
pl.show()
def fixticks(current_data):
from pylab import ticklabel_format, plot,grid,gca
ticklabel_format(useOffset=False)
if xmax is not None:
plot(xmax, etamax, 'r')
xlimits = gca().get_xlim()
print('+++ xlimits = ',xlimits)
import pdb; pdb.set_trace()
grid(True)
def aa_innerprod(current_data):
from pylab import ticklabel_format, xticks, gca, cos, pi, yticks
plotcc(current_data)
title_innerproduct(current_data)
ticklabel_format(format='plain',useOffset=False)
xticks([180, 200, 220, 240], rotation=20, fontsize = 28)
pylab.tick_params(axis='y', labelleft='off')
a = gca()
a.set_aspect(1./cos(41.75*pi/180.))
def aa_innerprod(current_data):
from pylab import ticklabel_format, xticks, gca, cos, pi, yticks
plotcc(current_data)
title_innerproduct(current_data)
ticklabel_format(format='plain',useOffset=False)
xticks([180, 200, 220, 240], rotation=20, fontsize = 28)
pylab.tick_params(axis='y', labelleft='off')
a = gca()
a.set_aspect(1./cos(41.75*pi/180.))
def aa(current_data):
from pylab import ticklabel_format, xticks, gca, cos, pi, yticks
plotcc(current_data)
title(current_data)
ticklabel_format(format='plain',useOffset=False)
xticks([180, 200, 220, 240], rotation=20, fontsize = 28)
yticks(fontsize = 28)
a = gca()
a.set_aspect(1./cos(41.75*pi/180.))
def aa(current_data):
from pylab import ticklabel_format, xticks, gca, cos, pi, imshow, savefig
addgauges(current_data)
title_hours(current_data)
ticklabel_format(format='plain', useOffset=False)
xticks(rotation=20)
#extent = (235.8756, 235.9116, 46.854, 46.8756)
#imshow(OcostaGE,extent=extent, alpha=0.5)
a = gca()
a.set_aspect(1. / cos(46.86 * pi / 180.))
def aa(current_data):
from pylab import ticklabel_format, xticks, gca, cos, pi, yticks, grid
plotcc(current_data)
title_hours(current_data)
ticklabel_format(format='plain', useOffset=False)
xticks(rotation=20, fontsize=10)
yticks(fontsize=10)
a = gca()
a.set_aspect(1. / cos(41.75 * pi / 180.))
grid(True)
def aa(current_data):
from pylab import ticklabel_format, xticks, gca, cos, pi, imshow, savefig
addgauges(current_data)
title_hours(current_data)
ticklabel_format(format="plain", useOffset=False)
xticks(rotation=20)
# extent = (235.8756, 235.9116, 46.854, 46.8756)
# imshow(OcostaGE,extent=extent, alpha=0.5)
a = gca()
a.set_aspect(1.0 / cos(46.86 * pi / 180.0))
def aa_patches(current_data):
import pylab
pylab.ticklabel_format(format='plain', useOffset=False)
pylab.xticks([180, 200, 220, 240], rotation=20, fontsize=28)
pylab.yticks(fontsize=28)
t = current_data.t
t = t / 3600. # hours
pylab.title('Grids patches at %4.2f hours' % t, fontsize=20)
a = pylab.gca()
a.set_aspect(1. / pylab.cos(41.75 * pylab.pi / 180.))
pylab.grid(True)
def plot_SandI(susceptible, infected, Title):
pl.figure(figsize=(5,3))
pl.plot(time, susceptible,label="Susceptible")
pl.fill_between(time, susceptible, 0, alpha=0.30)
pl.plot(time, infected,label="Infected")
pl.fill_between(time, infected, 0, alpha=0.30)
pl.ticklabel_format(axis="y", style="sci", scilimits=(0,0))
pl.xlabel('Time in days', fontsize=14)
pl.ylabel('Individuals', fontsize=14)
pl.title(Title)
pl.legend()
def aa(current_data):
from pylab import ticklabel_format, xticks, gca, cos, pi, imshow, savefig, plot
from pyclaw.plotters.plottools import plotbox
# addgauges(current_data)
title_hours(current_data)
ticklabel_format(format="plain", useOffset=False)
xticks(rotation=20)
a = gca()
# a.set_aspect(1./cos(46.86*pi/180.))
a.set_aspect(1.0 / cos(46.349 * pi / 180.0))
plot([235.9499], [46.3490], "wo")
def aa(current_data):
from pylab import ticklabel_format, xticks, gca, cos, pi, imshow, savefig
from clawpack.visclaw.plottools import plotbox
#addgauges(current_data)
title_hours(current_data)
ticklabel_format(useOffset=False)
xticks(rotation=20)
a = gca()
a.set_aspect(1./cos(46.86*pi/180.))
if current_data.t > 40*60.:
extent = (235.8756, 235.9116, 46.854, 46.8756)
plotbox(extent)
def aa(current_data):
from pylab import ticklabel_format, xticks, gca, cos, pi, imshow, \
savefig, plot
from pyclaw.plotters.plottools import plotbox
#addgauges(current_data)
title_hours(current_data)
ticklabel_format(format='plain', useOffset=False)
xticks(rotation=20)
a = gca()
#a.set_aspect(1./cos(46.86*pi/180.))
a.set_aspect(1. / cos(46.349 * pi / 180.))
plot([235.9499], [46.3490], 'wo')
def plotdata(noiselessData):
aD.plot_parameters()
fig = pylab.figure(1, (7, 5))
fig.add_subplot(111)
for noiseless in noiselessData:
pylab.plot(noiseless.noiselessData, label=noiseless.voltage)
pylab.ticklabel_format(style='sci', scilimits=(0, 0))
pylab.xlabel("Time [s]")
pylab.ylabel("Voltage [V]")
pylab.legend(loc=4, ncol=5)
pylab.grid()
pylab.tight_layout()
pylab.show()
def plotResults(results):
fig = pylab.figure(20, (7, 5))
fig.add_subplot(111)
pylab.plot(results["Voltage"], results["MIPs"], "ko", fillstyle="none")
pylab.ticklabel_format(axis="x", style='sci', scilimits=(-1, 4))
pylab.ticklabel_format(axis="y", style='sci', scilimits=(0, 2))
pylab.ylabel("MIPs")
pylab.xlabel("Voltage [V]")
pylab.legend(loc=4, ncol=5)
pylab.grid()
pylab.tight_layout()
pylab.savefig("mipsVsVoltage.png")
pylab.close()
def mostrar_gráfico(X, Y, F):
C = ['r', 'b', 'g', 'c', 'm', 'y', 'k', 'w']
M = ['o', 's', 'p', 'h', '+', 'x', 'v', '^']
xlabel('tamanho da entrada')
ylabel('tempo de execução (s)')
ticklabel_format(style='sci', axis='both', scilimits=(-3, +4))
grid(True)
for i, f in enumerate(F):
plot(X,
Y[i],
color=C[i % len(C)],
marker=M[i % len(M)],
label=f.__name__)
legend(loc='upper left')
show()
def run():
x = []
y = []
for i in range(1, 1001):
x.append(i / 100.0)
y.append((planckFunction(i * 10**-8, 2850.0)))
pylab.ticklabel_format(axis='y', style='sci',
scilimits=(-3, 4)) # label in scientific notation
pylab.plot(x, y, linewidth='2.5', label='2850 K')
pylab.xlabel('Wavelength (µm)')
pylab.ylabel('Spectral radiance (W m$^{−2}$ µm$^{−1}$ sr$^{−1}$)')
pylab.legend()
pylab.show()
def createLines(pStrip,ySpecs,isY1=True,y2Exists=False):
'''Create data lines from specifications; this code is common for y1 and y2 axes;
it handles y-data specified as callables, which might create additional lines when updated with liveUpdate.
'''
# save the original specifications; they will be smuggled into the axes object
# the live updated will run yNameFuncs to see if there are new lines to be added
# and will add them if necessary
yNameFuncs=set([d[0] for d in ySpecs if callable(d[0])]) | set([d[0].keys for d in ySpecs if hasattr(d[0],'keys')])
yNames=set()
ySpecs2=[]
for ys in ySpecs:
# ys[0]() must return list of strings, which are added to ySpecs2; line specifier is synthesized by tuplifyYAxis and cannot be specified by the user
if callable(ys[0]): ySpecs2+=[(ret,ys[1]) for ret in ys[0]()]
elif hasattr(ys[0],'keys'): ySpecs2+=[(yy,'') for yy in ys[0].keys()]
else: ySpecs2.append(ys)
if len(ySpecs2)==0:
print 'yade.plot: creating fake plot, since there are no y-data yet'
line,=pylab.plot([nan],[nan])
line2,=pylab.plot([nan],[nan])
currLineRefs.append(LineRef(line,None,line2,[nan],[nan]))
# set different color series for y1 and y2 so that they are recognizable
if pylab.rcParams.has_key('axes.color_cycle'): pylab.rcParams['axes.color_cycle']='b,g,r,c,m,y,k' if not isY1 else 'm,y,k,b,g,r,c'
for d in ySpecs2:
yNames.add(d)
line,=pylab.plot(data[pStrip],data[d[0]],d[1],label=xlateLabel(d[0]))
line2,=pylab.plot([],[],d[1],color=line.get_color(),alpha=afterCurrentAlpha)
# use (0,0) if there are no data yet
scatterPt=[0,0] if len(data[pStrip])==0 else (data[pStrip][current],data[d[0]][current])
# if current value is NaN, use zero instead
scatter=pylab.scatter(scatterPt[0] if not math.isnan(scatterPt[0]) else 0,scatterPt[1] if not math.isnan(scatterPt[1]) else 0,s=scatterSize,color=line.get_color(),**scatterMarkerKw)
currLineRefs.append(LineRef(line,scatter,line2,data[pStrip],data[d[0]]))
axes=line.get_axes()
labelLoc=(legendLoc[0 if isY1 else 1] if y2Exists>0 else 'best')
l=pylab.legend(loc=labelLoc)
if hasattr(l,'draggable'): l.draggable(True)
if scientific:
pylab.ticklabel_format(style='sci',scilimits=(0,0),axis='both')
# fixes scientific exponent placement for y2: https://sourceforge.net/mailarchive/forum.php?thread_name=20101223174750.GD28779%40ykcyc&forum_name=matplotlib-users
if not isY1: axes.yaxis.set_offset_position('right')
if isY1:
pylab.ylabel((', '.join([xlateLabel(_p[0]) for _p in ySpecs2])) if p not in xylabels or not xylabels[p][1] else xylabels[p][1])
pylab.xlabel(xlateLabel(pStrip) if (p not in xylabels or not xylabels[p][0]) else xylabels[p][0])
else:
pylab.ylabel((', '.join([xlateLabel(_p[0]) for _p in ySpecs2])) if (p not in xylabels or len(xylabels[p])<3 or not xylabels[p][2]) else xylabels[p][2])
# if there are callable/dict ySpecs, save them inside the axes object, so that the live updater can use those
if yNameFuncs:
axes.yadeYNames,axes.yadeYFuncs,axes.yadeXName,axes.yadeLabelLoc=yNames,yNameFuncs,pStrip,labelLoc # prepend yade to avoid clashes
def test_verify_AIS(self):
model = iRBM(input_size=self.input_size,
hidden_size=self.hidden_size,
beta=self.beta)
model.W.set_value(self.W)
model.b.set_value(self.b)
model.c.set_value(self.c)
# Brute force
print "Computing lnZ using brute force (i.e. summing the free energy of all posible $v$)..."
V = theano.shared(value=cartesian([(0, 1)] * self.input_size, dtype=config.floatX))
brute_force_lnZ = logsumexp(-model.free_energy(V), 0)
f_brute_force_lnZ = theano.function([], brute_force_lnZ)
params_bak = [param.get_value() for param in model.parameters]
print "Approximating lnZ using AIS..."
import time
start = time.time()
try:
ais_working_dir = tempfile.mkdtemp()
result = compute_AIS(model, M=self.nb_samples, betas=self.betas, seed=1234, ais_working_dir=ais_working_dir, force=True)
logcummean_Z, logcumstd_Z_down, logcumstd_Z_up = result['logcummean_Z'], result['logcumstd_Z_down'], result['logcumstd_Z_up']
std_lnZ = result['std_lnZ']
print "{0} sec".format(time.time() - start)
import pylab as plt
plt.gca().set_xmargin(0.1)
plt.errorbar(range(1, self.nb_samples+1), logcummean_Z, yerr=[std_lnZ, std_lnZ], fmt='or')
plt.errorbar(range(1, self.nb_samples+1), logcummean_Z, yerr=[logcumstd_Z_down, logcumstd_Z_up], fmt='ob')
plt.plot([1, self.nb_samples], [f_brute_force_lnZ()]*2, '--g')
plt.ticklabel_format(useOffset=False, axis='y')
plt.show()
AIS_logZ = logcummean_Z[-1]
assert_array_equal(params_bak[0], model.W.get_value())
assert_array_equal(params_bak[1], model.b.get_value())
assert_array_equal(params_bak[2], model.c.get_value())
print np.abs(AIS_logZ - f_brute_force_lnZ())
assert_almost_equal(AIS_logZ, f_brute_force_lnZ(), decimal=2)
finally:
shutil.rmtree(ais_working_dir)
def plot_from_list( list_of_coordinates, fitfunction="nullfit", cubicspline=True, xticks=-1, yticks=-1 ):
'''Plots the given list. The list should be in the following format:
[[x1,y1], [x2,y2], [x3,y3], [x4,y4], .. ]
:param list_of_coordinates List of coordinates to be plotted
'''
index = 1
fig = pl.figure()
for i in list_of_coordinates:
#title="(" + i[2] + "," + i[3] + ")"
pl.subplot(len(list_of_coordinates), 1, index)
#ax = fig.add_subplot(len(list_of_coordinates), 1, index)
x = i[0]
y = i[1]
pl.xlabel(i[2])
pl.ylabel(i[3])
xlength = max(x) - min(x)
ylength = max(y) - min(y)
pl.xlim([min(x) - 0.01*xlength, max(x) + 0.01*xlength])
pl.ylim([min(y) - 0.05*ylength, max(y) + 0.05*ylength])
plot_variables(x,y,False,fitfunction,cubicspline=cubicspline)
pl.ticklabel_format(style='sci', axis='y', scilimits=(-3,3))
# Set y ticks
if yticks > 0 and len(i) == 4:
ticks = min(y) + np.arange(yticks + 1) / (float)(yticks)*ylength
print len(i)
from decimal import *
getcontext().prec = 2
# Get two decimals
ticks = [float(Decimal(j)/Decimal(1)) for j in ticks]
pl.yticks(ticks)
print ticks
# Set x ticks
if xticks > 0 and len(i) == 4:
ticks = min(x) + np.arange(xticks + 1) / (float)(xticks)*xlength
from decimal import *
getcontext().prec = 2
# Get two decimals
ticks = [float(Decimal(j)/Decimal(1)) for j in ticks]
pl.xticks(ticks)
index = index + 1
#pl.tight_layout()
pl.ion()
pl.show()
def plotDepth():
d = pd.read_pickle(utl.outpath + 'real/D.F59.df').replace({0: 1})
z = pd.Series(np.ndarray.flatten(d.values))
plt.figure(figsize=(8, 8), dpi=100);
plt.subplot(2, 1, 1);
sns.distplot(z, bins=180, norm_hist=False, kde=False);
plt.xlim([0, 200]);
plt.xlabel('Depth');
plt.ylabel('Number of Measurments' + ' (out of {:.1f}M)'.format(z.shape[0] / 1e6));
plt.ticklabel_format(axis='y', style='sci', scilimits=(0, 0))
plt.subplot(2, 1, 2);
sns.distplot(d.min(1), bins=50, norm_hist=False, kde=False);
plt.xlim([0, 200]);
plt.xlabel('Minimum Depth of each Site');
plt.ylabel('Number of Sites' + ' (out of {:.1f}M)'.format(d.shape[0] / 1e6));
plt.ticklabel_format(axis='y', style='sci', scilimits=(0, 0))
plt.savefig(utl.paperFiguresPath + 'depth.pdf')
def plotDepth():
sns.set_style("whitegrid", {"grid.color": "1", 'axes.linewidth': .5, "grid.linewidth": ".09"})
sns.set_context("notebook", font_scale=1.4, rc={"lines.linewidth": 2.5})
d = pd.read_pickle(utl.outpath + 'real/CD.F59.df').xs('D', level='READ', axis=1)
(d.min(1) > 50).sum()
(d > 50).sum().sum()
z = pd.Series(np.ndarray.flatten(d.values))
fontsize = 6
mpl.rcParams.update({'font.size': fontsize})
plt.figure(figsize=(6, 4), dpi=300);
plt.subplot(2, 2, 1);
z.value_counts().sort_index().plot()
plt.xlim([0, 200]);
plt.xlabel('Depth');
plt.ylabel('Number of Measurments' + '\n (out of {:.1f}M)'.format(z.shape[0] / 1e6));
plt.ticklabel_format(axis='y', style='sci', scilimits=(0, 0))
plt.title('Scaled PDF')
pplt.annotate('(A)', xpad=0.85, ypad=0.45, fontsize=fontsize)
plt.axvline(50, linestyle='--', linewidth=1, color='k')
pplt.setSize(plt.gca(), fontsize)
plt.subplot(2, 2, 2);
z.value_counts().sort_index().cumsum().plot()
plt.xlim([0, 200])
plt.ylim([-3e5, 2.05 * 1e7])
plt.xlabel('Depth');
plt.title('Scaled CDF')
pplt.annotate('(B)', xpad=0.85, ypad=0.45, fontsize=fontsize)
plt.axvline(50, linestyle='--', linewidth=1, color='k')
pplt.setSize(plt.gca(), fontsize)
plt.subplot(2, 2, 3);
d.min(1).value_counts().sort_index().plot()
plt.xlim([0, 100]);
plt.xlabel('Minimum Depth of each Variant');
plt.ylabel('Number of Variants' + '\n (out of {:.1f}M)'.format(d.shape[0] / 1e6));
plt.ticklabel_format(axis='y', style='sci', scilimits=(0, 0))
plt.rc('font', size=fontsize)
pplt.annotate('(C)', xpad=0.85, ypad=0.45, fontsize=fontsize)
plt.axvline(50, linestyle='--', linewidth=1, color='k')
pplt.setSize(plt.gca(), fontsize)
plt.subplot(2, 2, 4);
d.min(1).value_counts().sort_index().cumsum().plot()
plt.xlim([0, 60])
plt.ylim([0.25 * -1e5, plt.ylim()[1]])
plt.xlabel('Minimum Depth of each Variant');
plt.ticklabel_format(axis='y', style='sci', scilimits=(0, 0))
pplt.annotate('(D)', xpad=0.85, ypad=0.45, fontsize=fontsize)
plt.axvline(50, linestyle='--', linewidth=1, color='k')
pplt.setSize(plt.gca(), fontsize)
plt.gcf().subplots_adjust(bottom=0.15)
plt.gcf().tight_layout(h_pad=0.1)
fontsize = 6
mpl.rc('font', **{'family': 'serif', 'serif': ['Computer Modern'], 'size': fontsize});
mpl.rc('text', usetex=True)
mpl.rcParams.update({'font.size': 1})
pplt.savefig('depth', 300)
plt.show()
def plotgaus(self,exp=None):
"""quickly plots the simulated gaussian isotope pattern"""
import pylab as pl
try:
pl.plot(self.gausip[0],self.gausip[1],linewidth=1)
except AttributeError:
self.gausip = self.gaussianisotopepattern()
pl.plot(self.gausip[0],self.gausip[1],linewidth=1)
if exp is not None: # plots experimental if supplied
y = []
maxy = max(exp[1])
for val in exp[1]: # normalize
y.append(val/maxy*100)
comp = self.compare(exp)
pl.plot(exp[0],exp[1])
pl.text(max(exp[0]),95,'SER: '+`comp`)
#pl.fill_between(x,self.gausip[1],exp[1],where= exp[1] =< self.gausip[1],interpolate=True, facecolor='red')
pl.fill(self.gausip[0],self.gausip[1],facecolor='blue',alpha=0.25)
pl.xlabel('m/z', style='italic')
pl.ylabel('normalized intensity')
pl.ticklabel_format(useOffset=False)
pl.show()
def P_AP(folder,keys):
for f in folder:
a=Analysis.AnalyseFile()
a.add_column(f.column('Current'),'Current')
a.add_column(f.column('Mean'),'NLV')
fit, fitVar= a.curve_fit(quad,'Current','NLV',bounds=lambda x,y:abs(x)>200e-6,result=True,header='Fit')
plt.title(r'')
plt.xlabel(r'Temperature (K)')
plt.ylabel(r'$\beta$ (V/A$^2$)')
plt.ticklabel_format(style='plain', scilimits=(3 ,3))
plt.hold(True)
'''
if f['IVtemp'] == 5:
plt.plot(a.column('Current'),a.column('NLV'),'b')
plt.plot(a.column('Current'),a.column('Fit'),'k')
'''
print f['state'],f['IVtemp']
if f['state'] == 'P':
#plt.plot(f['IVtemp'],fit[0],'ro')
print fitVar
plt.errorbar(f['IVtemp'],fit[0],numpy.sqrt(fitVar[0,0]),ecolor='k',marker='o',mfc='red', mec='k',ms=15.0)
print 'p'
if f['state'] == 'AP':
print 'ap'
plt.errorbar(f['IVtemp'],fit[0],numpy.sqrt(fitVar[0,0]),ecolor='k',marker='o',mfc='blue', mec='k',ms=15.0)
#plt.plot(f['IVtemp'],fit[0],'bx')
#plt.legend()
plt.savefig('/Users/Joe/PhD/Talks/MMM13/beta.eps', bbox_inches=0)
plt.show()
def plot_stat_without_eq(dictionary, file, location=None):
fig = pylab.figure()
count = 0
print(type(dictionary))
lis = sorted(dictionary.keys())
for key in lis:
count+=1
axes = dictionary.get(key)
filename = str(file) + '.png'
fig.add_subplot(4, 2, (count))
pylab.ticklabel_format(style='sci', axis = 'both', scilimits=(0,0))
pylab.plot(axes.get('x'), axes.get('y'), str(1), color='0.4', marker='o', markeredgecolor='0.4')
pylab.xlabel('iTRAQAnalyzer')
pylab.ylabel('Protein Pilot')
pylab.rc('font', size=5.5)
# z[0] denotes slope, z[1] denotes the intercept
z = np.polyfit(axes.get('x'), axes.get('y'), 1)
p = np.poly1d(z)
coeff = np.corrcoef(axes.get('x'), axes.get('y'))
pylab.plot(axes.get('x'), p(axes.get('x')), "r-", color='0')
print "y=%.6fx+(%.6f)"%(z[0],z[1])
# pylab.text(0.1, 0.3, "y=%.6fx+(%.6f)"%(z[0],z[1]))
print str(coeff[0][1])
pylab.title(str(key))
pylab.tight_layout()
graph = pylab.gcf()
graph.canvas.set_window_title(str(filename))
graph.savefig(location + '/' + filename)
pylab.close()
pl.xticks(pl.arange(len(terms))+1, (terms))
#ax1.set_xticks(pl.arange(len(terms))[::2]+1)
#ax1.set_xticklabels(terms[::2])ls
#ax2.set_xticks(pl.arange(len(terms))[::2]+1.5)
#ax2.set_xticklabels(terms[1:len(terms)-1:2])
#ax1.tick_params(axis='x', which='major', labelsize=10)
pl.xlim(0.5, len(terms)+0.5)
if levels[0].e/EV_TO_CM == 0:
pl.ylim((levels[0].e/EV_TO_CM-0.2), round(ION.e/EV_TO_CM+0.5))
#pl.ylim((levels[0].e/EV_TO_CM-0.2), round(levels[-1].e/EV_TO_CM+0.5))
if not IL:
pl.ylim(-0.2, round(max(levels).e/EV_TO_CM+0.5))
try:
pl.ticklabel_format(useOffset=False)
except AttributeError:
pass
# Plot collision transitions
if CT_THEO:
for i, llev in enumerate(fl+ml+sl+hl):
for j, ulev in enumerate((fl+ml+sl+hl)[i+1:]):
term_l = llev.remove_label_term(llev.term)
term_u = ulev.remove_label_term(ulev.term)
e_l = llev.e/EV_TO_CM
e_u = ulev.e/EV_TO_CM
#print(terms.index(term_l)+1, terms.index(term_u)+1, [e_l, e_u])
try:
ct_theo_line, = pl.plot([terms.index(term_l)+1, terms.index(term_u)+1], [e_l, e_u], 'k-')
def plot_mass_spectrum(realspec, simdict={}, **kwargs):
"""
Plots and saves a publication quality mass spectrum with optional overlaid isotope patterns
**Parameters**
realspec: *list*
A paired list of x and y values of the form ``[[x values],[y values]]``
simdict: *dictionary* or *list* or *string*, optional
This can either be a molecular formula to predict the isotope pattern of (string),
a list of formulae, or a dictionary of the form
``simdict = {'formula1':{'colour':<hex or name or RGB tuple>, 'alpha':float}, ...}``.
If this is dictionary is left empty, no isotope patterns will be overlaid on the output
spectrum.
**Returns**
returns: ``None``
This function has not pythonic output.
**\*\*kwargs**
annotations: None
Annotations for the spectrum in dictionary form: ``{'thing to print':[x,y],}``. Options: dictionary or ``None``
axwidth: 1.5
Line width for the axes and tick marks. Options: float.
bw: 'auto'
The width of the bar in *m/z* for bar isotope patterns. Options: 'auto' or float
This only has an affect if *simtype* is 'bar'.
Auto make the bars equal to 2 times the full width at half max of the peak they are simulating.
delta: False
Whether to calculate and output the mass delta between the exact mass predicted by the isotope pattern
simulation and the location of the maximum intensity within the bounds specified by *normwindow*.
Options: bool.
dpiout: 300
The dots per inch for the output figure. Options: integer.
exten: 'png'
The file extension for the output figure. Options: 'png', 'svg', or other supported by matplotlib.
fs: 16
Font size to use for labels. Options: integer or float.
lw: 1.5
Line width for the plotted spectrum. Options: float.
maxy: 'max'
The maximum y value for the spectrum. Options: 'max' or specify a value
mz: 'auto'
The *m/z* bounds for the output spectrum. Default: 'auto', but can be supplied
with a tuple or list of length 2 of the form ``[x start, x end]``.
norm: True
Normalize the spectrum. Options: bool
normwindow: 'fwhm'
The *m/z* window width within with too look for a maximum intensity value.
This will only have an effect if *delta* is ``True``.
Options: 'fwhm' for full width at half max or float.
offsetx: True
Whether to offset the x-axis slightly. Options: bool.
Enabling this shows makes it easier to see low intensity peaks.
outname: 'spectrum'
Name of the file to be saved.
output: 'save'
Save ('save') or show ('show') the figure.
padding: 'auto'
This allows the user to specify the subplot padding of the output figure.
Options: 'auto' or list of the form ``[left,right,bottom,top]`` scalars.
res_label: False
Whether to output the resolution of the spectrum onto the figure. Options: bool.
resolution:
Override the auto-resolution calculation with a specified instrument resolution
showx: True
Whether to show the x-axis line. Options: bool.
showy: True
Whether to show the y-axis line. Options: bool.
simlabels: False
Whether to show the names of the simulated isotope patterns. Options: bool.
The names will be exactly as supplied in ``simdict``.
simnorm: 'spec'
Normalize the isotope pattern simulations to what value. Options: 'top', 'spec', or specify a value.
Top will normalize the patterns to ``maxy``, and will only function if maxy is not 'max'.
Spec will normalize the patterns to the maximum spectrum y value within the x bounds of the
simulated pattern.
Specifying a value will normalize all isotope patterns to that value.
simtype: 'bar'
The type for the isotope pattern simulation overlay. Options: 'bar' or 'gaussian'.
size: [7.87,4.87]
The size in inches for the output figure. This must be a list of length 2 of the form
``[width,height]``.
speccolour: 'k'
The colour for the real spectrum , # colour for the spectrum to be plotted
specfont: 'Arial'
The font to use for text in the plot. The specified font must be accepted by matplotlib.
spectype: 'continuum'
The type of spectrum being handed to the function. Options: 'continuum' or 'centroid'.
stats: False
Whether to calculate and output the goodness of fit between the predicted isotope pattern and
the supplied spectrum. This functionality is still a work in progress. Options: bool.
verbose: True
Verbose option for the script. Options: bool.
xlabel: True
Whether to show the label for the *m/z* axis. Options: bool.
xvalues: True
Whether to show the values of the x-axis. Options: bool.
ylabel: True
Whether to show the y-axis label. Options: bool.
yvalues: True
Whether to show the values of the y-axis. Options: bool.
"""
def checksimdict(dct):
"""
checks the type of simdict, converting to dictionary if necessary
also checks for alpha and colour keys and adds them if necessary (defaulting to key @ 0.5)
"""
if type(dct) is not dict:
if type(dct) is str:
dct = {dct: {}}
elif type(dct) is list or type(dct) is tuple:
tdct = {}
for i in dct:
tdct[i] = {}
dct = tdct
for species in dct:
if 'colour' not in dct[species]:
dct[species]['colour'] = 'k'
if 'alpha' not in dct[species]:
dct[species]['alpha'] = 0.5
return dct
settings = { # default settings
'mz': 'auto', # m/z bounds for the output spectrum
'outname': 'spectrum', # name for the output file
'output': 'save', # 'save' or 'show' the figure
'simtype': 'bar', # simulation overlay type ('bar' or 'gaussian')
'spectype': 'continuum', # spectrum type ('continuum' or 'centroid')
'maxy': 'max', # max or value
'norm': True, # True or False
'simnorm': 'spec', # top, spec, or value
'xlabel': True, # show x label
'ylabel': True, # show y label
'xvalues': True, # show x values
'yvalues': True, # show y values
'showx': True, # show x axis
'showy': True, # how y axis
'offsetx': True, # offset x axis (shows low intensity species better)
'fs': 16, # font size
'lw': 1.5, # line width for the plotted spectrum
'axwidth': 1.5, # axis width
'simlabels': False, # show labels isotope for patterns
'bw': 'auto', # bar width for isotope patterns (auto does 2*fwhm)
'specfont': 'Arial', # the font for text in the plot
'size': [7.87, 4.87], # size in inches for the figure
'dpiout': 300, # dpi for the output figure
'exten': 'png', # extension for the output figure
'resolution': None, # resolution to use for simulations (if not specified, automatically calculates)
'res_label': False, # output the resolution of the spectrum
'delta': False, # output the mass delta between the spectrum and the isotope patterns
'stats': False, # output the goodness of match between the spectrum and the predicted isotope patterns,
'speccolour': 'k', # colour for the spectrum to be plotted
'padding': 'auto', # padding for the output plot
'verbose': True, # verbose setting
'normwindow': 'fwhm',
# the width of the window to look for a maximal value around the expected exact mass for a peak
'annotations': None, # annotations for the spectrum in dictionary form {'thing to print':[x,y],}
'normrel': 100., # the maximum value for normalization
'ipmol_kwargs': {}, # IPMolecule keyword arguments
}
if set(kwargs.keys()) - set(settings.keys()): # check for invalid keyword arguments
string = ''
for i in set(kwargs.keys()) - set(settings.keys()):
string += ' %s' % i
raise KeyError('Unsupported keyword argument(s): %s' % string)
settings.update(kwargs) # update settings from keyword arguments
if settings['resolution'] is None:
if settings['spectype'] != 'centroid':
res = autoresolution(realspec[0], realspec[1]) # calculate resolution
else:
res = 5000
else:
res = settings['resolution']
simdict = checksimdict(simdict) # checks the simulation dictionary
for species in simdict: # generate Molecule object and set x and y lists
simdict[species]['colour'] = Colour(simdict[species]['colour'])
simdict[species]['mol'] = IPMolecule(species, resolution=res, **kwargs['ipmol_kwargs'])
# simdict[species]['mol'] = Molecule(species, res=res, dropmethod='threshold')
if settings['simtype'] == 'bar':
simdict[species]['x'], simdict[species]['y'] = simdict[species]['mol'].barip
if settings['simtype'] == 'gaussian':
simdict[species]['x'], simdict[species]['y'] = simdict[species]['mol'].gausip
if settings['mz'] == 'auto': # automatically determine m/z range
if settings['verbose'] is True:
sys.stdout.write('Automatically determining m/z window')
mz = [10000000, 0]
for species in simdict:
simdict[species]['bounds'] = simdict[species]['mol'].bounds # calculate bounds
if simdict[species]['bounds'][0] < mz[0]:
mz[0] = simdict[species]['bounds'][0] - 1
if simdict[species]['bounds'][1] > mz[1]:
mz[1] = simdict[species]['bounds'][1] + 1
if mz == [10000000, 0]:
mz = [min(realspec[0]), max(realspec[0])]
settings['mz'] = mz
if settings['verbose'] is True:
sys.stdout.write(': %i - %i\n' % (int(mz[0]), int(mz[1])))
sys.stdout.flush()
else: # catch for user specified m/z bounds
mz = settings['mz']
realspec[0], realspec[1] = trimspectrum(realspec[0], realspec[1], settings['mz'][0] - 1,
settings['mz'][1] + 1) # trim real spectrum for efficiency
if len(realspec[0]) == 0: # catch for empty spectrum post-trim (usually user error)
raise ValueError(f'There are no spectral values in the specified m/z bounds ({mz[0]}-{mz[1]}). Common causes: '
f'no values in the loaded spectrum within the window of interest, an error in specifying the '
f'molecule(s) to simulate')
if settings['norm'] is True: # normalize spectrum
realspec[1] = normalize(realspec[1], settings['normrel'])
for species in simdict: # normalize simulations
if settings['simnorm'] == 'spec': # normalize to maximum around exact mass
if settings['normwindow'] == 'fwhm': # if default, look within the full width at half max
window = simdict[species]['mol'].fwhm
else: # otherwise look within the specified value
window = settings['normwindow']
simdict[species]['y'] = normalize(
simdict[species]['y'],
localmax(
realspec[0],
realspec[1],
simdict[species]['mol'].estimated_exact_mass,
window
)
)
elif settings['simnorm'] == 'top': # normalize to top of the y value
if settings['maxy'] == 'max':
raise ValueError('Simulations con only be normalized to the top of the spectrum when the maxy setting '
'is a specific value')
simdict[species]['y'] = normalize(simdict[species]['y'], settings['maxy'])
elif type(settings['simnorm']) is int or type(settings['simnorm']) is float: # normalize to specified value
simdict[species]['y'] = normalize(simdict[species]['y'], settings['simnorm'])
if settings['delta'] is True:
if settings['normwindow'] == 'fwhm': # if default, look within the full width at half max
window = simdict[species]['mol'].fwhm
else: # otherwise look within the specified value
window = settings['normwindow']
est = estimated_exact_mass( # try to calculate exact mass
realspec[0],
realspec[1],
simdict[species]['mol'].estimated_exact_mass,
simmin=simdict[species]['mol'].estimated_exact_mass,
simmax=simdict[species]['mol'].estimated_exact_mass,
lookwithin=window,
# min(simdict[species]['x']),
# max(simdict[species]['x'])
)
if type(est) is float:
simdict[species]['delta'] = '%.3f (%.1f ppm)' % (
simdict[species]['mol'].estimated_exact_mass - est, simdict[species]['mol'].compare_exact_mass(est))
else:
simdict[species]['delta'] = est
pl.clf() # clear and close figure if open
pl.close()
fig = pl.figure(figsize=tuple(settings['size']))
ax = fig.add_subplot(111)
ax.spines["right"].set_visible(False) # hide right and top spines
ax.spines["top"].set_visible(False)
if settings['showx'] is False:
ax.spines["bottom"].set_visible(False) # hide bottom axis
if settings['showy'] is False:
ax.spines["left"].set_visible(False) # hide left axis
for axis in ["top", "bottom", "left", "right"]:
ax.spines[axis].set_linewidth(settings['axwidth'])
if settings['offsetx'] is True: # offset x axis
ax.spines["bottom"].set_position(('axes', -0.01))
font = {'fontname': settings['specfont'], 'fontsize': settings['fs']} # font parameters for axis/text labels
tickfont = pl.matplotlib.font_manager.FontProperties( # font parameters for axis ticks
family=settings['specfont'],
size=settings['fs']
)
ax.set_xlim(settings['mz']) # set x bounds
if settings['maxy'] == 'max': # set y bounds
ax.set_ylim(0., max(realspec[1]))
top = max(realspec[1])
elif type(settings['maxy']) is int or type(settings['maxy']) is float:
ax.set_ylim(0., settings['maxy'])
top = settings['maxy']
if settings[
'simtype'] == 'bar': # generates zeros for bottom of bars (assumes m/z spacing is equal between patterns)
for species in simdict:
simdict[species]['zero'] = []
for i in simdict[species]['x']:
simdict[species]['zero'].append(0.)
for species in simdict: # for each species
for subsp in simdict: # look at all the species
if subsp != species: # if it is not itself
ins = bisect_left(simdict[subsp]['x'], simdict[species]['x'][-1]) # look for insertion point
if 0 < ins < len(simdict[subsp]['x']): # if species highest m/z is inside subsp list
for i in range(ins): # add intensity of species to subsp zeros
# used -ins+i-1 to fix an error, with any luck this won't break it next time
simdict[subsp]['zero'][i] += simdict[species]['y'][-ins + i]
# include resolution if specified (and spectrum is not centroid)
if settings['res_label'] is True and settings['spectype'] != 'centroid':
ax.text(
mz[1],
top * 0.95,
f'resolution: {str(round(res))}',
horizontalalignment='right',
**font
)
for species in simdict: # plot and label bars
if settings['simtype'] == 'bar':
if settings['bw'] == 'auto':
bw = simdict[species]['mol'].fwhm * 2
else:
bw = settings['bw']
ax.bar(
simdict[species]['x'],
simdict[species]['y'],
bw,
alpha=simdict[species]['alpha'],
color=simdict[species]['colour'].mpl,
linewidth=0,
align='center',
bottom=simdict[species]['zero']
)
elif settings['simtype'] == 'gaussian':
ax.plot(
simdict[species]['x'],
simdict[species]['y'],
alpha=simdict[species]['alpha'],
color=simdict[species]['colour'].mpl,
linewidth=settings['lw']
)
ax.fill_between(
simdict[species]['x'],
0,
simdict[species]['y'],
alpha=simdict[species]['alpha'],
color=simdict[species]['colour'].mpl,
linewidth=0
)
# if any labels are to be shown
if settings['simlabels'] is True or settings['stats'] is True or settings['delta'] is True:
string = ''
bpi = simdict[species]['y'].index(max(simdict[species]['y'])) # index of base peak
if settings['simlabels'] is True: # species name
string += species
if settings['stats'] is True or settings['delta'] is True: # add return if SER or delta is called for
string += '\n'
if settings['stats'] is True: # standard error of regression
string += f'SER: {simdict[species]["mol"].compare(realspec)} '
if settings['delta'] is True: # mass delta
string += f'mass delta: {simdict[species]["delta"]}'
ax.text(
simdict[species]['x'][bpi],
top * 1.01,
string,
color=simdict[species]['colour'].mpl,
horizontalalignment='center',
**font
)
if settings['spectype'] == 'continuum':
ax.plot(
realspec[0],
realspec[1],
linewidth=settings['lw'],
color=Colour(settings['speccolour']).mpl
)
elif settings['spectype'] == 'centroid':
dist = []
for ind, val in enumerate(realspec[0]): # find distance between all adjacent m/z values
if ind == 0:
continue
dist.append(realspec[0][ind] - realspec[0][ind - 1])
dist = sum(dist) / len(dist) # average distance
ax.bar(
realspec[0],
realspec[1],
dist * 0.75,
linewidth=0,
color=Colour(settings['speccolour']).mpl,
align='center',
alpha=0.8
)
if settings['annotations'] is not None:
for label in settings['annotations']:
ax.text(
settings['annotations'][label][0],
settings['annotations'][label][1],
label,
horizontalalignment='center',
**font
)
# show or hide axis values/labels as specified
if settings['yvalues'] is False: # y tick marks and values
ax.tick_params(axis='y', labelleft='off', length=0)
if settings['yvalues'] is True: # y value labels
ax.tick_params(
axis='y',
length=settings['axwidth'] * 3,
width=settings['axwidth'],
direction='out',
right='off'
)
for label in ax.get_yticklabels():
label.set_fontproperties(tickfont)
if settings['ylabel'] is True: # y unit
if top == 100: # normalized
ax.set_ylabel('relative intensity', **font)
else: # set to counts
ax.set_ylabel('intensity (counts)', **font)
if settings['xvalues'] is False: # x tick marks and values
ax.tick_params(axis='x', labelbottom='off', length=0)
if settings['xvalues'] is True: # x value labels
ax.tick_params(
axis='x',
length=settings['axwidth'] * 3,
width=settings['axwidth'],
direction='out',
top='off'
)
for label in ax.get_xticklabels():
label.set_fontproperties(tickfont)
if settings['xlabel'] is True: # x unit
ax.set_xlabel('m/z', style='italic', **font)
pl.ticklabel_format(useOffset=False) # don't use the stupid shorthand thing
if settings['padding'] == 'auto':
pl.tight_layout(pad=0.5) # adjust subplots
if settings['simlabels'] is True or settings['stats'] is True or settings['delta'] is True:
pl.subplots_adjust(top=0.90) # lower top if details are called for
elif type(settings['padding']) is list and len(settings['padding']) == 4:
pl.subplots_adjust(
left=settings['padding'][0],
right=settings['padding'][1],
bottom=settings['padding'][2],
top=settings['padding'][3]
)
if settings['output'] == 'save': # save figure
outname = '' # generate tag for filenaming
for species in simdict:
outname += ' ' + species
outname = settings['outname'] + outname + '.' + settings['exten']
pl.savefig(
outname,
dpi=settings['dpiout'],
format=settings['exten'],
transparent=True
)
if settings['verbose'] is True:
sys.stdout.write('Saved figure as:\n"%s"\nin the working directory' % outname)
elif settings['output'] == 'show': # show figure
pl.show()
def draw_RA(ROSAs, title=''):
'''
Draw RA figure
ROSAs: a dict of several ROSA results
Every ROSA result is also a dict.
title='': title of the figure
'''
keys = ROSAs.keys()
xsize, ysize = 6, 6
#draw RA figure
max_r = 3.
RA_fig = pylab.figure(figsize=(xsize, ysize))
ax2 = RA_fig.add_subplot(111)
ax2.plot(0, 0, 'ks')
ax2.axvline(x=0, color='k', linestyle=':')
ax2.axhline(y=0, color='k', linestyle=':')
X, Y = [], []
U, V = [], []
rs, thetas = [], []
for k in keys:
x = ROSAs[k]['r_rate']
X.append(x)
y = ROSAs[k]['Hu_dist']
Y.append(y)
ax2.plot(x, y, 'ko')
Xlim = ax2.get_xlim()
lx = 0.2/xsize * (Xlim[1]-Xlim[0])
Ylim = ax2.get_ylim()
ly = 0.2/ysize * (Ylim[1]-Ylim[0])
ax2.set_xlim(Xlim[0]-2*lx, Xlim[1]+2*lx)
ax2.set_ylim(Ylim[0]-2*ly, Ylim[1]+2*ly)
Xlim = ax2.get_xlim()
lx = 0.2/xsize * (Xlim[1]-Xlim[0])
Ylim = ax2.get_ylim()
ly = 0.2/ysize * (Ylim[1]-Ylim[0])
for k in keys:
r = ROSAs[k]['ecc']
rs.append(r)
theta = ROSAs[k]['angle'] * numpy.pi/180.
thetas.append(theta)
u = r * numpy.cos(theta)
U.append(u)
v = r * numpy.sin(theta)
V.append(v)
ll = min(lx, ly)
for i, k in enumerate(keys):
x = X[i]
y = Y[i]
ax2.text(x+0.5*lx, y+0.5*ly, k, color='k')
u = U[i]
v = V[i]
theta = thetas[i]
delta_x = numpy.cos(theta)
delta_y = numpy.sin(theta)
U = numpy.array(U)
V = numpy.array(V)
N_uv = numpy.sqrt(U**2 + V**2)
#U1 = 0.15 * U/N_uv
#V1 = 0.15 * V/N_uv
U1 = []
V1 = []
for i in range(len(U)):
if N_uv[i] != 0:
U1.append(0.15 * U[i]/N_uv[i])
V1.append(0.15 * V[i]/N_uv[i])
else:
U1.append(0.)
V1.append(0.)
U1 = numpy.array(U1)
V1 = numpy.array(V1)
ax2.quiver(X, Y, U, V, scale_units='inches', scale=0.254, width=0.004)
ax2.quiver(X, Y, U1, V1, scale_units='inches', scale=0.254, width=0.00001, headwidth=1, linestyle='dotted', facecolor='none', linewidth=0.5) #dotted line
ax2.set_title(r'%s RA figure' % title)
ax2.set_xlabel(r'Relative bias of amount $R$', labelpad=12)
ax2.set_ylabel(r"Bias of Hu's moments $S_{HU}$", labelpad=0)
for tick in ax2.xaxis.get_major_ticks():
tick.label.set_fontsize('x-small')
for tick in ax2.yaxis.get_major_ticks():
tick.label.set_fontsize('x-small')
pylab.ticklabel_format(style='sci', axis='y', scilimits=(0, 0))
RA_fig.savefig('%s-RA.pdf' % title)
pylab.close()
return RA_fig
print a.column(1)
fit, fitVar = a.curve_fit(lin, 1, 0)
print fit, fitVar
error = numpy.sqrt(fitVar[0, 0])
print error
t = 96e-9
w = 1130e-9
l = 30e-6
print fit[0] * t * w / l
alpha = 1e6
beta = 1
# plt.title(a['Sample ID'] + ' - ' + a['Notes'] + ' at ' + str.format("{0:.1f}",a['Sample Temp']) + ' K')
plt.xlabel(r"Current ($\mu$A)")
plt.ylabel(r"Voltage (V)")
plt.ticklabel_format(style="sci", useOffset=False)
plt.tick_params(axis="both", which="minor")
plt.plot(
a.column("1"),
a.column("0"),
"-o",
label="R = " + str.format("{0:.2f}", fit[0]) + r"$\pm$" + str.format("{0:.2f}", error) + r" $\Omega$",
)
plt.plot(a.column("1"), (fit[1] + (a.column("1") * fit[0])), "-r", label="Fit")
plt.legend(loc=2)
plt.tight_layout()
plt.show()
dt = datetime(2000, 1, 1)
lat = 0
lon = 0
iri_ne = []
for alt_i in alt:
point = Point(dt, lat, lon, alt_i)
point.run_iri()
iri_ne.append(point.ne)
Nm_star, Hm_star, H_O_star = chapman_fit(alt, iri_ne, verbose=True)
chapman_ne = [chapman(z, Nm_star, Hm_star, H_O_star) for z in alt]
fig = PL.figure(figsize=(6,10))
PL.plot(iri_ne,
alt,
color='b',
label='IRI')
PL.plot(chapman_ne,
alt,
color='g',
label='Chapman fit')
PL.legend()
PL.xlabel('Electron density [cm$^{-3}$]')
PL.ylabel('Height [km]')
PL.ticklabel_format(style='sci', axis='x', scilimits=(0,0))
PL.axis('tight')
PL.show()
a[1] = xt[-1]
a[2] = yt[0]
a[3] = yt[-1]
pylab.axis(a)
pylab.savefig('../figs/%spermutations.pdf' % prefix)
pylab.figure(8, figsize=figsize)
pylab.clf()
u = np.random.random(10**6)
pylab.subplot(2,1,1)
pylab.hist(np.log(u), 100)
pylab.text(-15.5, 10**5, '$N$ = 1,000,000\n100 bins', fontsize=fs-2)
pylab.xticks(fontsize=fs)
(a, b) = pylab.yticks()
pylab.yticks(a[:-1:2])
pylab.ticklabel_format(style='sci', axis='y', scilimits=(0,0))
pylab.yticks(fontsize=fs)
pylab.rc('font', **{'size':fs})
pylab.ylabel('count', fontsize=fs)
pylab.title('Histograms of $\\log$ $u$, $u$ ~ Unif(0, 1)', fontsize=fs)
pylab.subplot(2,1,2)
pylab.hist(np.log(u), 100, log=True)
pylab.ylabel('count (log scale)', fontsize=fs)
pylab.xticks(fontsize=fs)
pylab.yticks(fontsize=fs)
(a, b) = pylab.yticks()
pylab.yticks(a[2:-1:2])
pylab.xlabel('$\\log$ $u$\n', fontsize=fs)
pylab.savefig('../figs/%suniform.pdf' % prefix)
pylab.figure(6, figsize=figsize)
AP = a.mean('Rs',bounds = lambda x: x<Ref)
DeltaR = P-AP
print DeltaR
Perr = (numpy.std(a.search('Rs',lambda x,y:x>Ref,'Rs')))/numpy.sqrt(len(a.search('Rs',lambda x,y:x>Ref,'Rs'))) # error in average value for P state
APerr = (numpy.std(a.search('Rs',lambda x,y:x<Ref,'Rs')))/numpy.sqrt(len(a.search('Rs',lambda x,y:x<Ref,'Rs')))
DeltaRerr = numpy.sqrt((Perr*Perr)+(APerr*APerr)) #calculate error in Delta R in micro Ohms
print DeltaRerr
plt.title()
plt.xlabel('B (T)')
plt.ylabel(r'R$_s$ ($\mu$V/A)')
plt.ticklabel_format(style = 'sci', useOffset = False)
plt.tick_params(axis='both', which='minor')
plt.plot(data.column('Field'),data.column('Rs (microOhms)'),'-ob')
#matplotlib.pyplot.grid(False)
#plt.show()
b=Analysis.AnalyseFile()
for f in folder:
Rmax = numpy.max(f.column('Resistance'))
Rmin = numpy.min(f.column('Resistance'))
offset = ((Rmax-Rmin)/2)+Rmin
for i in range(0,len(f.column('Res'))-1,1):
if f.column('Resistance')[i]>offset and f.column('Resistance')[i+1]<offset:
folder = DataFolder('/Users/Joe/PhD/Measurements/RN0151_4T/NLIVvsT/Both/',pattern = pattern)
folder.group(['state','IVtemp'])
folder.walk_groups(IV_group_Avg,group=True,replace_terminal=True)
folder.walk_groups(P_AP_col,group=True,replace_terminal=True)
print folder['AP']
for f in folder:
for column in f.column_headers:
plt.title(r'NL IV offset vs Temperature for Parallel (red) and Antiparallel (blue) State')
plt.xlabel(r'Temperature (K)')
plt.ylabel(r'$\alpha$ ($\mu$V/A) ')
plt.ticklabel_format(style='plain', scilimits=(3 ,3))
plt.hold(True)
plt.grid(True)
if folder['state'] == 'P':
plt.errorbar(folder['IVtemp'],folder['P'].column('Mean Coef')[1],folder['P'].column('Err Coef')[1],ecolor='k',marker='o',mfc='red', mec='red')
else:
plt.errorbar(folder['IVtemp'],folder['AP'].column('Mean Coef')[1],folder['AP'].column('Err Coef')[1],ecolor='k',marker='o',mfc='blue', mec='blue')
#plt.legend()
plt.show()
else:
plt.errorbar(axisrange, params[0][x], xerr = params[1][x], \
marker='.', color = 'red', \
ecolor = 'grey', linestyle = 'none',capsize = 0)
if log == True:
ax.set_yscale('log')
ax.set_xscale('log')
ax.yaxis.set_major_formatter(matplotlib.ticker.ScalarFormatter())
else:
plt.ticklabel_format(style='sci', scilimits=(0,0))
if labels:
for index in range(len(params[0][0])):
plt.annotate(index +1,
xy = (params[0][x][index], params[0][y][index]),
xytext = (-20,20),
textcoords = 'offset points', ha = 'right', va = 'bottom',
bbox = dict(boxstyle = 'round,pad=0.5', fc = 'blue', alpha = 0.5),
arrowprops = dict(arrowstyle = '->',
connectionstyle = 'arc3,rad=0'))
#plt.ylim([-2.7,1.95])
#plt.xlim([0.0,0.015])
def fixticks1(current_data):
from pylab import ticklabel_format
ticklabel_format(format='plain',useOffset=False)
def fixticks(current_data):
from pylab import ticklabel_format, plot
ticklabel_format(format='plain',useOffset=False)
if xmax is not None:
plot(xmax, etamax, 'r')
import Stoner
from Stoner.Folders import DataFolder
# from pylab import arange,pi,sin,cos,sqrt
################ READ FILE INFO ########################
# filename = tkFileDialog.askopenfilename(message = 'Pick first file', title = 'Pick file ')
# workingpath = filename.rpartition('/')[0]
####### IMPORT DATA ######
folder = DataFolder(False, pattern="*.txt")
for f in folder:
Ref = ((max(f.Resistance) - min(f.Resistance)) / 2) + min(f.Resistance)
Field = f.column("Control:Magnet Output")
plt.title("NL dc R vs H for different Temp")
plt.xlabel(r"Field (T)")
plt.ylabel(r"Resistance ($\mu$R)")
plt.ticklabel_format(style="plain", scilimits=(3, 3))
plt.hold(True)
plt.plot(Field, f.column("Resistance") * 1e6, label=str(f.metadata["Sample Temp"]))
plt.grid(True)
plt.legend()
plt.show()
