def makeplot(X,hjd,filename,ephem):
if ephem == 1:
# archive ephem
T0 = 2452525.374416
elif ephem == 2:
# august ephem
T0 = 2453964.330709
P = 0.154525
#X = pl.load(filename)
a = X[:,0][:-1]
p = X[:,1][:-1]
x = (X[:,2][:-1]+hjd-T0)/P - int(((X[:,2][:-1]+hjd-T0)/P)[0])
siga = X[:,3][:-1]
sigp = X[:,4][:-1]
temp = []
temp.append(a)
temp.append(p)
temp.append(x)
temp.append(siga)
temp.append(sigp)
pl.save(filename[:-4] + 'OP' + '.dat',pl.array(temp).transpose())
def __call__(self,output_fn,init_time=0,final_time=None,**params):
p=ParamOverrides(self,params)
if final_time is None:
final_time=topo.sim.time()
attrs = p.attrib_names if len(p.attrib_names)>0 else output_fn.attrib_names
for a in attrs:
pylab.figure(figsize=(6,4))
isint=pylab.isinteractive()
pylab.ioff()
pylab.grid(True)
ylabel=p.ylabel
pylab.ylabel(a+" "+ylabel)
pylab.xlabel('Iteration Number')
coords = p.units if len(p.units)>0 else output_fn.units
for coord in coords:
y_data=[y for (x,y) in output_fn.values[a][coord]]
x_data=[x for (x,y) in output_fn.values[a][coord]]
if p.raw==True:
plot_data=zip(x_data,y_data)
pylab.save(normalize_path(p.filename+a+'(%.2f, %.2f)' %(coord[0], coord[1])),plot_data,fmt='%.6f', delimiter=',')
pylab.plot(x_data,y_data, label='Unit (%.2f, %.2f)' %(coord[0], coord[1]))
(ymin,ymax)=p.ybounds
pylab.axis(xmin=init_time,xmax=final_time,ymin=ymin,ymax=ymax)
if isint: pylab.ion()
pylab.legend(loc=0)
p.title=topo.sim.name+': '+a
p.filename_suffix=a
self._generate_figure(p)
def __create_three_d_model__(self):
"""
__create_three_d_model__: helper function for create_three_d_model
"""
heightLevels = pl.linspace(
0.0, abs(self.Parameters.eh - self.Parameters.sh), self.NumImages)
# Now, simply find max variance at each pixel 'cluster' in the stack.
self.ThreeDModel = pl.zeros(self.VoLImageStack[0].shape)
iterationsSinceUpdate = pl.zeros(
self.VoLImageStack[0].shape,
dtype=pl.uint8) # track num iterations since updated
print "[x] Creating 3D Model of Size",
print "(l x w x h): ", self.ThreeDModel.shape[
0], "x", self.ThreeDModel.shape[1], "x", self.NumImages
for index, laplacianOfImMatrix in enumerate(self.VoLImageStack):
pointsInFocus = 0
for row in pl.arange(laplacianOfImMatrix.shape[0]):
for col in pl.arange(laplacianOfImMatrix.shape[1]):
if laplacianOfImMatrix[row][col] > self.ThreeDModel[row][
col] and iterationsSinceUpdate[row][
col] < self.Parameters.mai + 1: # add one so that self.Parameters.mai iterations actually pass before cell is blocked
pointsInFocus += 1
self.ThreeDModel[row][col] = heightLevels[index]
if index > 0:
iterationsSinceUpdate[row][col] = 1
else:
if iterationsSinceUpdate[row][
col] != 0: # make sure cell has stopped being updated BEYOND first iteration
iterationsSinceUpdate[row][col] += 1
print "\t[", index + 1, "] Percentage of Pixel Clusters Updated: ", pointsInFocus, "/", laplacianOfImMatrix.size, "=",
print float(pointsInFocus) / laplacianOfImMatrix.size
# This time, store results using numpy since we're dealing with an array object
with open(internalFilesDir + internalThreeDModel, 'wb') as f:
pl.save(f, self.ThreeDModel)
def save(self, basename, append=""):
pylab.save('%s%s.dat' % (basename, append), self.cartesian.data, fmt='%g')
pylab.save('%s_x%s.dat' % (basename, append), self.cartesian.data.sum(axis=0), fmt='%g')
pylab.save('%s_y%s.dat' % (basename, append), self.cartesian.data.sum(axis=1), fmt='%g')
pylab.save('%s_r%s.dat' % (basename, append), self.polar.data.sum(axis=0), fmt='%g')
pylab.save('%s_encircled%s.dat' % (basename, append), self.polar.data.sum(axis=0).cumsum(), fmt='%g')
file('%s%s_R50.dat' % (basename, append), 'w').write('%s' % (self.rforfraction(0.5)))
def load_default(path, closure):
from pylab import load, save
try:
return load(path)
except IOError:
obj = closure()
save(obj, path)
return obj
def OnBSavePointsButton(self, event):
fn = wx.SaveFileSelector('Save point positions to file', '.txt')
if fn == None:
print('No file selected')
return
#self.points = pylab.load(fn)
pylab.save(fn, scipy.array(self.points))
def OnBSavePointsButton(self, event):
fn = wx.SaveFileSelector('Save point positions to file', '.txt')
if fn is None:
print('No file selected')
return
#self.points = pylab.load(fn)
pylab.save(fn, scipy.array(self.points))
def getParamCovMat(prefix,dlogpower = 2, theoconstmult = 1.,dlogfilenames = ['dlogpnldloga.dat'],volume=256.**3,startki = 0, endki = 0, veff = [0.]):
"""
Calculates parameter covariance matrix from the power spectrum covariance matrix and derivative term
in the prefix directory
"""
nparams = len(dlogfilenames)
kpnl = M.load(prefix+'pnl.dat')
k = kpnl[startki:,0]
nk = len(k)
if (endki == 0):
endki = nk
pnl = M.array(kpnl[startki:,1],M.Float64)
covarwhole = M.load(prefix+'covar.dat')
covar = covarwhole[startki:,startki:]
if len(veff) > 1:
sqrt_veff = M.sqrt(veff[startki:])
else:
sqrt_veff = M.sqrt(volume*M.ones(nk))
dlogs = M.reshape(M.ones(nparams*nk,M.Float64),(nparams,nk))
paramFishMat = M.reshape(M.zeros(nparams*nparams*(endki-startki),M.Float64),(nparams,nparams,endki-startki))
paramCovMat = paramFishMat * 0.
# Covariance matrices of dlog's
for param in range(nparams):
if len(dlogfilenames[param]) > 0:
dlogs[param,:] = M.load(prefix+dlogfilenames[param])[startki:,1]
normcovar = M.zeros(M.shape(covar),M.Float64)
for i in range(nk):
normcovar[i,:] = covar[i,:]/(pnl*pnl[i])
M.save(prefix+'normcovar.dat',normcovar)
f = k[1]/k[0]
if (volume == -1.):
volume = (M.pi/k[0])**3
#theoconst = volume * k[1]**3 * f**(-1.5)/(12.*M.pi**2) #1 not 0 since we're starting at 1
for ki in range(1,endki-startki):
for p1 in range(nparams):
for p2 in range(nparams):
paramFishMat[p1,p2,ki] = M.sum(M.sum(\
M.inverse(normcovar[:ki+1,:ki+1]) *
M.outerproduct(dlogs[p1,:ki+1]*sqrt_veff[:ki+1],\
dlogs[p2,:ki+1]*sqrt_veff[:ki+1])))
paramCovMat[:,:,ki] = M.inverse(paramFishMat[:,:,ki])
return k[1:],paramCovMat[:,:,1:]
def Signal():
global E_imfNo
E_imfNo = np.zeros(50, dtype=np.int)
# EEMD options
max_imf = 7
"""
信号参数：
N:采样频率500Hz
tMin:采样开始时间
tMax:采样结束时间 2*np.pi
"""
N = 500
tMin, tMax = 0, 2 * np.pi
T = np.linspace(tMin, tMax, N)
# 信号S:是多个信号叠加信号
S = 3 * np.sin(4 * T) + 4 * np.cos(9 * T) + np.sin(8.11 * T + 1.2)
# EEMD计算
eemd = EEMD()
eemd.trials = 50
eemd.noise_seed(12345)
E_IMFs = eemd.eemd(S)
imfNo = E_IMFs.shape[0]
# Plot results in a grid
c = np.floor(np.sqrt(imfNo + 1))
r = np.ceil((imfNo + 1) / c)
plt.ioff()
plt.subplot(r, c, 1)
plt.plot(T, S, 'r')
plt.xlim((tMin, tMax))
plt.title("Original signal")
i = 1
for imf in E_IMFs:
plt.subplot(len(E_IMFs), 1, i)
plt.plot(imf)
i += 1
# for num in range(imfNo):
# plt.subplot(r, c, num + 2)
# plt.plot(T, E_IMFs[num], 'g')
# plt.xlim((tMin, tMax))
# plt.title("Imf " + str(num + 1))
plt.text(0,
0,
str(format(i, '.4f')),
style='italic',
ha='center',
wrap=True)
plt.save("haha.jpg")
def write_multi_par_out(check,names,par,t1,t2,filename,func,const,const_names,xbase1='none', xbase2='none', fileno='none',fileout='params.out',qval='none',file_input='input_fit.txt'):
multi = 'on'
if check==0:
write_par_out(names,par,t1,t2,filename,func,const,const_names,xbase1,xbase2,fileno,fileout,multi,qval)
else:
f=open(fileout,'a')
outpar=zeros((1,len(par)+1))
outpar[0,0]=float(qval)
outpar[0,1:]=par[:]
Plab.save(f,outpar)
f.close()
def degraderesolution(prefix,factor,dlogstring):
covar = M.load(prefix+'covar.dat')
pnl = M.load(prefix+'pnl.dat')
dlog = M.load(prefix+dlogstring)[:,1]
k = pnl[:,0]*1.
p = pnl[:,1]*1.
gausspart = M.load(prefix+'gausspart.dat')
nbins = len(k)
nongausspart = covar - gausspart
nongausspartnew = nongausspart[:nbins-factor:factor,:nbins-factor:factor]*0.
knew = k[:nbins-factor:factor]*0.
pnew = p[:nbins-factor:factor]*0.
gausspartnew = gausspart[:nbins-factor:factor,:nbins-factor:factor]*0.
nbinsnew = len(knew)
dlognew = dlog[:nbins-factor:factor]*0.
for i1 in range(0,nbins-factor,factor):
i1new = i1/factor
print i1,i1+factor-1,nbins
print i1new,nbinsnew
weights = k[i1:i1+factor-1]**3
sumweights = M.sum(weights)
pnew[i1new] = M.sum(p[i1:i1+factor-1]*weights)/sumweights
knew[i1new] = M.sum(k[i1:i1+factor-1]*weights)/sumweights
dlognew[i1new] = M.sum(dlog[i1:i1+factor-1]*weights)/sumweights
sqrtkfact = M.sqrt(k[1]/k[0])
for i1 in range(0,nbins-factor,factor):
i1new = i1/factor
for i2 in range(0,nbins-factor,factor):
i2new = i2/factor
weights2 = M.outer(k[i1:i1+factor-1]**3,k[i2:i2+factor-1]**3)
sumweights2 = M.sum(M.sum(weights2))
nongausspartnew[i1new,i2new] = M.sum(M.sum(nongausspart[i1:i1+factor-1,i2:i2+factor-1]*weights2))/sumweights2
if i1new == i2new:
vk = (4.*M.pi/3.)*((k[i1+factor-1]*sqrtkfact)**3 - (k[i1]/sqrtkfact)**3)
gausspartnew[i1new,i2new] = (2.*M.pi)**3 * 2.*(pnew[i1new]**2)/vk
covarnew = gausspartnew + nongausspartnew
prefixnew = prefix+'degrade'+str(factor)+'/'
os.system('mkdir '+prefixnew)
M.save(prefixnew+'pnl.dat',M.transpose([knew,pnew]), fmt = '%18.16e')
M.save(prefixnew+'covar.dat',covarnew, fmt = '%18.16e')
M.save(prefixnew+'gausspart.dat',gausspartnew, fmt = '%18.16e')
M.save(prefixnew+dlogstring,M.transpose([knew,dlognew]), fmt = '%18.16e')
M.save(prefix+'nbins.dat',M.array([nbinsnew],shape=(1,1,)), fmt = '%d')
def get_pca(self, rld_df, n_components, plot=False):
df = rld_df.transpose()
pca = PCA(n_components=n_components)
X = pca.fit_transform(df)
if plot:
fig, ax = plt.subplots()
ax.scatter(X[:, 0], X[:, 1])
for i, txt in enumerate(df.index):
ax.annotate(txt, (X[i, 0], X[i, 1]))
plt.tight_layout()
fn = '{uuid}.png'.format(uuid=uuid.uuid4())
plt.save(fn)
cumsum = np.cumsum(pca.explained_variance_ratio_)
return X, cumsum
def save_ROI_spectra_perpixel(subdir, x, y, r, exp_name):
t = read_spectral_roi(subdir, x, y, r)
e = excitation_emission_cubes_to_spectra(t)
savedir = "ROISpectra_outputs/" + str(exp_name) + "perpixel_" + "x" + str(
x) + "_" + "y" + str(y) + "_" + "r" + str(r) + ".npy"
return (pl.save(savedir, e))
def getInfoCurve():
"""
Various functions to calculate example parameter error bars as in
Neyrinck & Szapudi 2007, MNRAS 375, L51
"""
c = pt.Camb(hubble = 70., ombh2 = 0.05*(0.7)**2, omch2 = 0.25*(0.7)**2)
c.run()
c.kextend(-10,60) # necessary to make sigma(m) integral converge well.
pt.normalizePk(c,0.8) #sigma_8
outputdir = 'example/'
#Sheth-Tormen
h = halo.HaloModel(c,st_big_a = 0., st_little_a=0.707, stq = 0.3, k = 10.**M.arange(-2,1.01,0.25),massdivsperdex=5)
#For final calculations, should use more massdivsperdex, e.g. 20 (maybe 10 is ok)
#also, k is really coarse, as you'll see if you run this.
# get covariance matrix from halo-model trispectrum (saves it in the 'prefix' directory)
# it also automatically runs halo.getHaloPknl
halo.getHaloCov(outputdir,c,h)
# power spectrum at h.k (range of k at which halo model quantities are evaluated)
M.loglog(h.k,h.pnl)
M.show()
# get derivs wrt ln A, tilt
h.dloga = halo.getdlogPnldCosmoParam(c,h,'scalar_amp',linlog='log')
h.dtilt = halo.getdlogPnldCosmoParam(c,h,'scalar_spectral_index',linlog='lin')
M.loglog(h.k,h.dloga**2,label='ln A')
M.loglog(h.k,h.dtilt**2,label='tilt')
M.legend()
M.show()
M.save(outputdir+'dlogpnldloga.dat',M.transpose([h.k,h.dloga]),fmt='%6.5e')
M.save(outputdir+'dlogpnldtilt.dat',M.transpose([h.k,h.dtilt]),fmt='%6.5e')
# get parameter covariance matrix (just a function of k, since there's only one variable)
k, covmat = info.getParamCovMat(outputdir,dlogfilenames=['dlogpnldloga.dat','dlogpnldtilt.dat'])
# plot the unmarginalized error bars in ln A and the tilt,
# if the matter power spectrum is analyzed from k= k[0] to k.
M.loglog(k, M.sqrt(covmat[0,0,:]),label='ln A')
M.loglog(k, M.sqrt(covmat[1,1,:]),label='tilt')
M.legend()
M.show()
def write_par_out(names,par,t1,t2,filename,func,const,const_names,xbase1='none',xbase2='none',fileno='none',fileout='params.out',multi='off',qval='none',file_input='input_fit.txt'):
info=get_input(file_input)
xcol=info['xcol']+' '
ycol=info['ycol']+' '
ynorm=info['normcol']+' '
yerr=info['yerr']+' '
f=open(fileout,'a')
sep=' '
f.write('#'+asctime()+'\n')
f.write('#'+70*'-'+'\n')
f.write('#fitted file= '+ filename +'\n')
f.write('#fitting function= '+ func + '\n')
f.write('#fitting range= ' + str(t1) + ':' + str(t2) + '\n')
f.write('#baseline range= ' +str(xbase1)+':' +str(xbase2) + '\n')
f.write('#xcol='+xcol+'\n')
f.write('#ycol='+ycol+'\n')
f.write('#ynorm='+ynorm+'\n')
f.write('#yerr='+yerr+'\n')
if const != []:
f.write('#parameters kept fixed:\n')
f.write('#'+sep.join(const_names)+'\n')
if len(const)>1:
f.write('#'+arraytostring(const)+'\n')
else:
f.write('#'+str(const)+'\n')
if multi=='on':
f.write('# ycol '+sep.join(names)+'\n')
outpar=zeros((1,len(par)+1))
outpar[0,0]=float(qval)
outpar[0,1:]=par[:]
Plab.save(f,outpar)
else:
f.write('#'+sep.join(names)+'\n')
if len(par)>1:
f.write(arraytostring(par)+'\n')
else:
f.write(str(par)+'\n')
f.write(70*'*'+'\n')
f.close()
def makeplot(X,hjd,filename,ephem):
if ephem == 1:
# archive ephem
T0 = 2452525.374416
elif ephem == 2:
# august ephem
T0 = 2453964.330709
P = 0.154525
#X = pl.load(filename)
x = (X[:,0]+hjd-T0)/P - int(((X[:,0]+hjd-T0)/P)[0])
y = X[:,1]
z = X[:,2]
temp = []
temp.append(x)
temp.append(y)
temp.append(z)
pl.save(filename[:-4] + 'OP' + '.dat',pl.array(temp).transpose())
from scipy import arange, sin, pi, randn, zeros
import pylab as p
a = 2 # 2 volt amplitude
f = 10 # 10 Hz frequency
sigma = 0.5 # 0.5 volt standard deviation noise
# create the t and v and store them a 2D array X
t = arange(0.0, 2.0, 0.02) # an evenly sampled time array
v = a*sin(2*f*pi*t) + sigma*randn(len(t)) # a noisy sine wave
X = zeros((len(t),2)) # an empty output array
X[:,0] = t # add t to the first column
X[:,1] = v # add s to the 2nd column
p.save('data/noisy_sine.dat', X) # save the output file as ASCII
# plot the arrays t vs v and label the x-axis, y-axis and title
# save the output figure as noisy_sine.png
p.plot(t, v, 'b-')
p.xlabel('time (s)')
p.ylabel('volts (V)')
p.title('A noisy sine wave')
p.grid()
p.savefig('noisy_sine.png', dpi=150)
p.savefig('noisy_sine.eps')
p.show()
raise ValueError, "smooth only accepts 1 dimension arrays."
if x.size < window_len:
raise ValueError, "Input vector needs to be bigger than window size."
if window_len<3:
return x
if not window in ['flat', 'hanning', 'hamming', 'bartlett', 'blackman']:
raise ValueError, "Window is on of 'flat', 'hanning', 'hamming', 'bartlett', 'blackman'"
s=numpy.r_[2*x[0]-x[window_len:1:-1],x,2*x[-1]-x[-1:-window_len:-1]]
#print(len(s))
if window == 'flat': #moving average
w=ones(window_len,'d')
else:
w=eval('numpy.'+window+'(window_len)')
y=numpy.convolve(w/w.sum(),s,mode='same')
return y[window_len-1:-window_len+1]
if __name__=='__main__':
data=pylab.load("spibgorig.dat")
print data
data.transpose()
bg=pylab.array([data[0],smooth(data[1], 200)])
bg.transpose()
print bg
pylab.save("spibgsmoothed.dat", bg)
# kill the low frequency bits > ~ 1hour
k = int(24.0*l*dt)
print k
fft[0:5] = 0.0
fft[-5:] = 0.0
yy = sci.ifft(fft)
pl.subplot(311)
pl.plot(x,y,'.')
pl.subplot(312)
pl.plot(x,yy,'-')
pl.subplot(313)
pl.plot(x,y-yy,'.')
pl.show()
temp = []
temp.append(x)
temp.append(yy)
temp.append(y-yy)
pl.save('HaFF.dat',pl.array(temp).transpose())
red = pl.load('Ha_red.dat')[:,0]
#X = pl.load('Ha_deblend.dat')
#red_vel = X[:,2]
#blue_vel = X[:,1]
#phase = X[:,0]
blue_vel = (blue - 6563.0) / 6563.0 * c
red_vel = (red - 6563.0) / 6563.0 * c
pl.figure(figsize=(6,4))
pl.plot(phase,blue_vel,'bo-')
pl.plot(phase,red_vel,'ro-')
pl.ylim(-750,750)
pl.ylabel('Line Velocity (km/s)')
pl.xlabel('Orbital Phase')
pl.show()
temp = []
temp.append(phase)
temp.append(blue_vel)
temp.append(red_vel)
pl.save('Ha_deblend.dat', pl.array(temp).transpose())
_ip.magic("run dirichlet_sparse_stats.py")
plot_results(r, case="0.1")
_ip.magic("run dirichlet_sparse_stats.py")
plot_results(r, case="0.1")
_ip.magic("run dirichlet_sparse_stats.py")
plot_results(r, case="0.1")
p.show()
p.figure()
#[Out]# <matplotlib.figure.Figure object at 0x118a80e90>
_ip.magic("run dirichlet_sparse_stats.py")
plot_results(r, case="0.1")
#?p.save
#?p.savefig
_ip.magic("pwd ")
#[Out]# '/Users/ivan/Homes/master/Documents/Projects/LatentDirichletAllocation/math'
p.save("alpha0.1sparseness.pdf")
p.savefig(fname="alpha0.1sparseness.pdf")
#?p.savefig
p.savefig("alpha0.1sparseness.pdf")
r = get_sparse_for_alpha(alphaval=0.01)
plot_results(r, case="0.01")
p.savefig("Dir_sparseness_a0dot01.pdf")
r01 = get_sparse_for_alpha(alphaval=0.1)
plot_results(r, case="0.1")
#p.savefig("Dir_sparseness_a0dot1.pdf")
plot_results(r01, case="0.1")
p.savefig("Dir_sparseness_a0dot1.pdf")
x = np.zeros(n)
#x = np.zeros(n)
n=4
x = np.zeros(n)
def test_save_using_pylab():
z=np.zeros([3,5])
path="/tmp/test.pl"
pl.save(path, z)
def multifit(lastcol,outdir,outpref,inputfile='input_fit.txt',doplot='yes'):
ndataset=int(lastcol)
if os.path.exists(inputfile) is False:
reply=raw_input('I need an input file, do you want me to create it?(Y/n)')
print reply
if reply=='n':
exit()
else:
print 'creating an input file'
inputfile= create_input(inputfile)
f=open(inputfile,'r')
text=f.read()
print text
test = raw_input('Is it ok?(Y/n)')
if test == 'n':
print 'Please correct it and launch the program again'
exit()
#reading input parameters####################################################
Input_par=get_input(inputfile)
pars = process_input(Input_par)
filename=pars[0]
t1=float(pars[1])
t2=float(pars[2])
range_par=pars[3]
func=pars[4]
name_const=pars[5]
const_0=pars[6]
name_par=pars[7]
par_0=pars[8]
xcol=pars[9]
ycol=pars[10]
normcol=pars[11]
#yerr=pars[12]
#input parameters read####################################################
g=open(filename,'r')
title=g.readline()
g.close()
qs=title.split(' ')
if doplot=='yes':
Plab.ion()
Plab.figure(1)
axdata=Plab.axes()
axdata.set_xlabel('t [sec]')
axdata.set_ylabel('g^2(q,t)')
ldata1,=axdata.semilogx((1,),(1,),'ko',label='all range')
axdata.hold(True)
ldata2,=axdata.semilogx((1,),(1,),'r^',label='fitting range')
ldata3,=axdata.semilogx((1,),(1,),'k-',label='fit')
axdata.legend(loc='lower left')
Plab.draw()
npars=len(name_par)
parplot=zeros((ndataset-ycol,npars),dtype=float32)
n=tuple(range(1,npars+1))
Plab.figure(2)
ncols=(1+npars)/2
nrows=npars/ncols+npars%ncols
ax=range(npars)
lpars=range(npars)
for k in range(npars):
s=str(ncols)+str(nrows)+str(k+1)
ax[k]=Plab.subplot(s)
ax[k].set_xlabel('q [1/Ang]')
ax[k].set_ylabel(name_par[k])
ax[k].set_title(name_par[k])
lpars[k],=ax[k].plot((1,),(1,),'ro-')
Plab.draw()
raw_input('Adjust positioning and size of figures, then press RETURN...')
for i in range(ycol,ndataset):
check=i-ycol
print 'reading file ', filename, ' ...', 'col no. ', i+1
x,y,not_used=read_data(filename,xcol,i,normcol)
print 'read'
if range_par=='in':
print 'including data in the range ', t1, ':', t2
if range_par=='out':
print 'excluding data in the range ', t1, ':', t2
if range_par=='all':
t1=Plab.min(x)
t2=Plab.max(x)
print 'using all x-range to fit:[',t1,'-',t2,']'
xfit,yfit,not_used=fit_region(x,y,t1,t2,range_par)
y_out,p,f= fitting(xfit,yfit,func,par_0,const_0)
#writing results#################################################
file_par_out=os.path.join(outdir,outpref+'_fitpar.dat')
file_data_out=os.path.join(outdir,outpref+'_fitcol'+str(i+1)+'.dat')
write_multi_par_out(check,name_par,p,t1,t2,filename,func,const_0,name_const,fileout=file_par_out,qval=qs[i+1],file_input=inputfile)
ytheo=eval(f)
mat=zeros((len(x),3),dtype=float32)
mat[:,0]=x
mat[:,1]=y
mat[:,2]=ytheo
fi=open(file_data_out,'w')
fi.write('# x y fit')
Plab.save(fi,mat)
fi.close()
print 'output written on files ', file_par_out,' and ', file_data_out
#some plots#####################################################
if doplot=='yes':
Plab.figure(1)
ldata1.set_data(x,y)
ldata2.set_data(xfit,yfit)
ldata3.set_data(x,ytheo)
axdata.set_xlim(Plab.min(x),Plab.max(x))
axdata.set_ylim(Plab.min(y),Plab.max(y))
Plab.draw()
q=qs[2:i+2]
parplot[i-1,:]=p
q=Plab.transpose(q)
Plab.figure(2)
for k in range(npars):
lpars[k].set_data(q,parplot[:i,k])
xmin=float(q[0])
xmax=float(q[-1])
ax[k].set_xlim(0.9*xmin,1.1*xmax)
ax[k].set_ylim(0.9*Plab.min(parplot[:i,k]),1.1*Plab.max(parplot[:i,k]))
Plab.draw()
if doplot=='yes':
raw_input( "Press a RETURN to close figures...")
Plab.close('all')
pl.xlim(0, pl.xlim()[1])
pl.ylim(pl.ylim()[0], 0)
coords = (coords[(coords[:, 0] > 5) * \
(coords[:, 0] < stack.shape[0] - 5) *\
(coords[:, 1] > 5) * \
(coords[:, 1] < stack.shape[1] - 5)])
print("Found %d good windows away from the edges"%len(coords))
for c in coords:
pl.plot(c[1], c[0], 'wo', alpha = 0.3)
pl.title("gaussian std %d, threshold %.1f, labels %d"%(GS,
thr,
np.sum(goodwindows)))
pl.savefig(args[0].replace(".npy", "_selectedwindows.pdf"))
if options.showme: pl.show()
pl.close()
# coords = np.array([coords[:, 1], coords[:, 0]])
pl.save(args[0].replace(".npy", "_coords.npy"), coords[:, 1::-1])
pl.save(args[0].replace(".npy", "_mask.npy"), mask)
# print (mask)
# for i in range(labels.max()+1):
# if i in labels:
# pl.figure()
# pl.imshow(mask[:i].sum(axis=0), interpolation='nearest',
# cmap='gist_gray')
# pl.savefig("mask.%04d.png"%i)
# pl.close('all')
solution = si.odeint(coupling_optim, y0, \
t,printmessg=1,rtol=1e-10,atol=1e-10)
elif (linear!=1):
solution = si.odeint(coupling_optim_garrick, y0, \
t,printmessg=1,rtol=1e-10,atol=1e-10)
total_monomers=total_concentration(solution, box_vol)
#now save the total number of monomers and the time in two separate files
if (linear==1):
p.save("number_monomers_linear_binning.dat", total_monomers)
elif (linear !=1):
p.save("number_monomers_nonlinear_binning.dat", total_monomers)
p.save("time.dat", t)
#check the quality of the simulation by testing mass conservation
mass_tests=total_mass_conservation(solution, vol_grid,box_vol)
print "initial and final total mass in the box are", mass_tests[0], mass_tests[1] ,"respectively"
def getHaloCov(prefix,c,h):
"""
Output halo model covariance matrix, correlation matrix into the directory 'prefix'
"""
os.system('mkdir '+prefix)
h.pnl = getHaloPknl(c,h)
M.save(prefix+'pnl.dat',M.transpose([h.k,h.pnl]), fmt = '%18.16e')
h.prefix = prefix
#h.dlogPnldlogA = getdlogPnldlogA(c,h)
#M.save(prefix+'dlogpnldloga.dat',M.transpose([h.k,h.dlogPnldlogA]),fmt='%6.5e')
vk = h.k*0.
vk[0] = (h.k[0]*h.k[1])**1.5 - (h.k[0]**3/h.k[1])**1.5
for k1 in M.arange(1,len(h.k)-1):
vk[k1] = (h.k[k1]*h.k[k1+1])**1.5 - (h.k[k1]*h.k[k1-1])**1.5
vk[-1] = (h.k[-1]**3/h.k[-2])**1.5 - (h.k[-1]*h.k[-2])**1.5
vk *= 4.*M.pi/3.
gausspart = M.outer(h.k*0.,h.k*0.)
for k1 in M.arange(len(h.k)):
gausspart[k1,k1] = (2.*M.pi)**3 * 2.*(h.pnl[k1]**2)/vk[k1]
if h.p.outputalltterms == 0:
t = getHaloTrispec(c,h, adder=gausspart)
elif h.p.outputalltterms == 1:
t,t10,t1h,t2h,t3h,t4h = getHaloTrispec(c,h, adder=gausspart)
elif h.p.outputalltterms == 2:
t,t10,t1h,t2h22,t2h31,t3hB,t3hnoB,t4hT,t4hnoT = getHaloTrispec(c,h,adder=gausspart)
covar = t*1.
cocg = h.k*0.
for k1 in M.arange(len(h.k)):
cocg[k1] = M.sqrt(covar[k1,k1]/gausspart[k1,k1])
covar += gausspart
M.save(prefix+'covar.dat',covar, fmt = '%18.16e')
M.save(prefix+'gausspart.dat',gausspart, fmt = '%18.16e')
#t10->pt.dat is the perturbation theory trispectrum by itself. However,
#it might not be calculated at high precision in the nonlinear
#regime, since where other things dominate on small scales, the
#first pass at calculating it is done with low precision.
#
if h.p.outputalltterms == 1:
M.save(prefix+'pt.dat',t10, fmt = '%18.16e')
M.save(prefix+'t1h.dat',t1h, fmt = '%18.16e')
M.save(prefix+'t2h.dat',t2h, fmt = '%18.16e')
M.save(prefix+'t3h.dat',t3h, fmt = '%18.16e')
M.save(prefix+'t4h.dat',t4h, fmt = '%18.16e')
if h.p.outputalltterms == 2:
M.save(prefix+'pt.dat',t10, fmt = '%18.16e')
M.save(prefix+'t1h.dat',t1h, fmt = '%18.16e')
M.save(prefix+'t2h22.dat',t2h22, fmt = '%18.16e')
M.save(prefix+'t2h31.dat',t2h31, fmt = '%18.16e')
M.save(prefix+'t3hB.dat',t3hB, fmt = '%18.16e')
M.save(prefix+'t3hnoB.dat',t3hnoB, fmt = '%18.16e')
M.save(prefix+'t4hT.dat',t4hT, fmt = '%18.16e')
M.save(prefix+'t4hnoT.dat',t4hnoT, fmt = '%18.16e')
correl = 0.*covar
tnorm = t
for i in M.arange(len(h.k)):
for j in M.arange(len(h.k)):
correl[i,j] = covar[i,j]/M.sqrt(covar[i,i]*covar[j,j])
M.save(prefix+'nbins.dat',M.array([len(h.k)]), fmt = '%d')
M.save(prefix+'correl.dat',correl, fmt = '%4.3f')
def test_save_using_pylab():
z = np.zeros([3, 5])
path = "/tmp/test.pl"
pl.save(path, z)
def generate_data(a_b, xl, type):
y = []
execution_time = []
particle = Spheroid(m, a_b, type)
particle.set_xl(xl)
id = str(a_b) + " " + str(xl) + " " + str(type)
for i in range(n_min, n_max, 2):
nmax = i
print nmax
start = time.time()
svm = SpheroidalSVM(particle, nmax)
b_sca = svm.getSolution(TMInputWave(alpha))[0]
C_ext = getCext(particle, alpha, b_sca, nmax)[0]
C_sca = getCsca(particle, b_sca, nmax)[0]
delta = (C_ext - C_sca) / (C_ext + C_sca)
execution_time.append(time.time() - start)
y.append(delta)
y = np.fabs(y)
save("svm_delta" + id, y)
save("svm_time" + id, execution_time)
y = []
execution_time = []
for i in range(n_min, n_max, 2):
nmax = i
print nmax
start = time.time()
ebcm = SpheroidalEBCM(particle, nmax)
b_sca = ebcm.getMatrixSolution(TMInputWave(alpha))[0]
C_ext = getCext(particle, alpha, b_sca, nmax)[0]
C_sca = getCsca(particle, b_sca, nmax)[0]
delta = (C_ext - C_sca) / (C_ext + C_sca)
execution_time.append(time.time() - start)
y.append(delta)
y = np.fabs(y)
save("ebcm_m_delta" + id, y)
save("ebcm_m_time" + id, execution_time)
y = []
execution_time = []
for i in range(n_min, n_max, 2):
nmax = i
print nmax
start = time.time()
ebcm = SpheroidalEBCM(particle, nmax)
b_sca = ebcm.getSolution(TMInputWave(alpha))[0]
C_ext = getCext(particle, alpha, b_sca, nmax)[0]
C_sca = getCsca(particle, b_sca, nmax)[0]
delta = (C_ext - C_sca) / (C_ext + C_sca)
execution_time.append(time.time() - start)
y.append(delta)
y = np.fabs(y)
save("ebcm_delta" + id, y)
save("ebcm_time" + id, execution_time)
y = []
execution_time = []
y.append(l)
i += 1
if (max_num > 0 and i >= max_num):
break
return np.array(x), np.array(y)
if (reload):
# Train set
x_train, y_train = read_data(train_image_paths, train_labeled_studies,
n_train, bone_name)
# Test set
x_test, y_test = read_data(valid_image_paths, valid_labeled_studies,
n_test, bone_name)
save(data_folder + "x_train_" + bone_name, x_train)
save(data_folder + "y_train_" + bone_name, y_train)
save(data_folder + "x_test_" + bone_name, x_test)
save(data_folder + "y_test_" + bone_name, y_test)
else:
# Load saved data
x_train = load(data_folder + "x_train_" + bone_name + ".npy")
y_train = load(data_folder + "y_train_" + bone_name + ".npy")
x_test = load(data_folder + "x_test_" + bone_name + ".npy")
y_test = load(data_folder + "y_test_" + bone_name + ".npy")
### Build the model:
import numpy as np
import scipy as sp
from matplotlib import pyplot as plt
from boutdata.collect import collect
from boututils.moment_xyzt import moment_xyzt
from boututils.file_import import file_import
from pylab import save, figure, plot, title, xlabel, ylabel, show, tight_layout
from elm_size import elm_size
path='./data'
t_array=collect('t_array', path=path)
save('t_array.dat', t_array)
p0=collect('P0', path=path)
save('p0.dat', p0)
# n0=collect('n0', path=path)
# save('n0.dat', n0
# ti0=collect('ti0', path=path)
# save('ti0.dat', ti0)
# te0=collect('te0', path=path)
# save('te0.idl.dat', te0)
gfile=file_import('./cbm18_dens8.grid_nx68ny64.nc')
p=collect('P', path=path)
save('p.dat', p)
res=moment_xyzt(p,'RMS','DC')
rmsp=res.rms
dcp=res.dc
save('rmsp.dat', rmsp)
save('dcp.dat', dcp)
elmsp=elm_size(dcp,p0,gfile,yind=32,Bbar=gfile['bmag'])
data_ecog_clean = pl.load(os.path.join(memap_folder,'data_ecog_clean.npy'), mmap_mode='r+')
data_ecog_mua_shaftC = pl.load(os.path.join(memap_folder,'data_ecog_mua_shaftC.npy'), mmap_mode='r+')
data_ecog_fft_norm_shaftA = pl.load(os.path.join(memap_folder, 'data_ecog_fft_norm_shaftA.npy'), mmap_mode=None)
data_ecog_fft_norm_shaftC = pl.load(os.path.join(memap_folder, 'data_ecog_fft_norm_shaftC.npy'), mmap_mode=None)
phases_all_shaftA = pl.load(os.path.join(memap_folder, 'phases_all_shaftA.npy'), mmap_mode=None)
phases_all_shaftC = pl.load(os.path.join(memap_folder, 'phases_all_shaftC.npy'), mmap_mode=None)
data = pl.load(os.path.join(memap_folder,'B14R9_raw.npy'), mmap_mode='r+')
# ----------Data generation-----------------
data = lio.read_all_csc(folder, assume_same_fs=False, memmap=True, memmap_folder=memap_folder, save_for_spikedetekt=False, channels_to_save=None, return_sliced_data=False)
pl.save(os.path.join(memap_folder, 'B14R9_raw.npy'), data)
data_ecog = data[:64,:]
data_probe = data[64:,:]
data_probe_hp = pl.memmap(os.path.join(memap_folder,'data_probe_hp.dat'), dtype='int16', mode='w+', shape=pl.shape(data_probe))
for i in pl.arange(0, pl.shape(data_probe)[0]):
data_probe_hp[i,:] = filters.high_pass_filter(data_probe[i, :], Fsampling=f_sampling, Fcutoff=f_hp_cutoff)
data_probe_hp.flush()
print(i)
pl.save(os.path.join(memap_folder, 'data_probe_hp.npy'), data_probe_hp)
shape_data_ss = (pl.shape(data_ecog)[0], pl.shape(data_ecog)[1]/int(f_sampling/f_subsample))
data_ecog_lp_ss = pl.memmap(os.path.join(memap_folder, 'data_ecog_lp_ss.dat'), dtype='int16', mode='w+', shape=shape_data_ss)
#pl.subplot(212)
#pl.plot(times-int(times[0]),kms,'.')
#pl.xlabel('Time (HJD)')
#pl.ylabel('Line Velocity (km/s)')
#pl.ylim(-250,250)
#pl.show()
temp = pl.zeros((len(times),4),dtype='float')
for i in range(len(times)):
temp[i,0] = times[i]
temp[i,1] = kms[i]
temp[i,2] = fwhm[i]
temp[i,3] = flux[i]
pl.save('%s_ew.dat'%line,temp)
results = []
times= []
kms = []
fwhm = []
flux = []
# plot the velocities of the lines and the photometry lightcurve
def lonepoly(X,
y,
Q,
m,
nbIter,
method,
lamb=0,
r=1,
nbRestart=1,
frein=True,
drawObj=False,
drawPartial=False,
thbet=10,
thgam=3):
'''
fonction qui résout le modèle polytomique ordonné sparse à lambda (ou r) fixé.
5 argument obligatoires 5 argument optionnels de methode, 2 arguments de dessin dessins, 2 inutiles maintenant (grade au cas ou).
Remarque : On peut également appliquer des "restart" si necessaire (d'ou la presence de deux boucles for imbriquées avec l1 et l2)
X : la Matrice patients * genes.
y : Le vecteur des détériorations.
n : Nombre de patients.
p : Nombre de gènes.
Q : Le nombre d'états de détérioration.
lamb : La pénalisation.
L : Le nombre d'itérations. Fixé à l'avance. (noté N dans l'article).
thbet et thgam : Limites à ne pas franchir pour les valeur de beta et gama (on peut les fixer à +- inf finalement.
Support = Vecteur de taille p qui vaut 0 pour les gènes non influants et 1 pour les gènes influants.
supp = Vecteur de taille inférieur à p qui garde l'indexe des gènes influants.
method possibles = Nesterov (N) GradianSimple (GS) Mixte (M) Frank-Wolf (FW) Online Frank-Wolfe (OFW)
'''
# Conditions initiales
n = X.shape[0]
p = X.shape[1]
bet0 = np.zeros((p, 1))
gam0 = np.vstack(range(Q - 1)) - Q / 2. + 1
bet = bet0
gam = gam0
thet0 = np.vstack([
bet, gam
]) # Serge : vstack merœge verticalement les données tout simplement.
thet = np.vstack([bet, gam])
mu = 0.005
h = 0 # indicateur de la qualité de l'évaluation pour un r donné (OFW).
if (method == 'OFW'):
X_l = np.zeros((0, p))
y_l = np.zeros((0, 1))
if drawObj:
GraphlossFunction = [
] # Permet de tracer le graphique de l'évolution de la fonction objective en fonction des itérations.
lossFunction = lossFunction(n, p, X, bet, gam, y, lamb, mu)
GraphlossFunction.append(lossFunction)
# Optimisation de la fonction objective.
for l1 in range(nbRestart):
if (method == 'N' or method == 'M'):
G = np.zeros((p + Q - 1,
0)) # G est une matrice à p+Q-1 ligne et 0 colonnes.
for l2 in range(nbIter):
if (method == 'GS'):
res = IterationGradianSimple(X, y, thet, bet, gam, mu, p, Q, n,
m, lamb, frein)
if (method == 'N'):
res = Iteration_Nesterov(X, y, thet, bet, gam, thet0, mu, l2,
p, Q, n, m, lamb, G, frein)
G = res[3]
if (method == 'M' and l2 < nbIter / 5):
res = IterationGradianSimple(X, y, thet, bet, gam, mu, p, Q, n,
m, lamb, frein)
if (method == 'M' and l2 >= nbIter / 5):
res = Iteration_Nesterov(X, y, thet, bet, gam, thet0, mu,
l2 - nbIter / 5, p, Q, n, m, lamb, G,
frein)
G = res[3]
if (method == 'FW'):
res = IterationFW(X, y, thet, bet, gam, p, Q, n, m, r, l2)
if (method == 'OFW'):
h = h + like(n, p, X, bet, gam, y)
if (l2 % n == 0):
np.random.seed(2111983 + l2 / n)
permu = np.random.permutation(range(n))
index = permu[l2 % n]
w_l_X = np.matrix(X.take(index, axis=0))
w_l_y = np.matrix(y.take(index, axis=0))
X_l = np.concatenate((X_l, w_l_X), axis=0)
y_l = np.concatenate((y_l, w_l_y), axis=0)
res = IterationOFW(X_l, y_l, thet, bet, gam, p, Q, l2 + 1, m,
r, l2)
if (method == 'QOFW'):
if (l2 % n == 0):
np.random.seed(2111983 + l2 / n)
permu = np.random.permutation(range(n))
index = permu[l2 % n]
X_l = X.take(index, axis=0)
y_l = y.take(index, axis=0)
res = IterationOFW(X_l, y_l, thet, bet, gam, p, Q, 1, m, r, l2)
thet = res[0]
bet = res[1]
gam = res[2]
if drawObj:
lossFunction = lossFunction(n, p, X, bet, gam, y, lamb, mu)
GraphlossFunction.append(lossFunction)
if drawPartial:
print "bet = ", bet
print "gradbet(X,y,n,p,bet,gam) = ", gradbet(
X, y, n, p, bet, gam, 0)
for i in range(len(gam)):
draw1DGam(n, p, X, bet, gam, m, y, lamb, mu, i, 100)
print "i = ", i, "gam = ", gam
for i in range(len(bet)):
draw1DBet(n, p, X, bet, gam, y, lamb, mu, i, 100)
#print "Like = ", like(n,p,X,bet,gam,y) , "l = ", l2
# Fin de l'alogorithme de d'optimisation. Mise en forme des outputs.
Support = (abs(bet) > .01)
if (
lamb == 0 and (method == 'N' or method == 'GS' or method == 'M')
): # Si lamba = 0, on conserve tout le support (mais pourquoi déjà????)
Support = (abs(bet) > -1)
supp = np.zeros((np.sum(Support)))
SizeS = size(supp, axis=0) # SizeS est la nouvelle valeur de p.
if SizeS > 70:
worked = 0 # Ca signifie qu'il y a une erreur je suppose.
else:
worked = 1
save('bet', bet)
jj = 0
for j in range(p):
if Support[j]:
supp[jj] = j
jj = jj + 1
if math.isnan(bet[j, 0]):
if j == 0:
print "erreur, le ", j, "eme coefficient de beta est ", bet[j,
0]
worked = 0
if SizeS > 0:
bet = np.transpose(np.asmatrix(bet.take([supp])))
if SizeS == 0:
bet = []
if drawObj:
GraphlossFunction = np.vstack(
GraphlossFunction
) # Ce paragraphe sert à tracer le graph de la fonction objective.
plt.plot(GraphlossFunction)
if frein:
chaine1 = 'avec recherche lineaire, '
chaine2 = '_avec_recherche_lineaire'
if (not frein):
chaine1 = ''
chaine2 = ''
if (method == 'Nesterov'):
plt.title('function Objective, Nesterov ' + chaine1 + 'lambda = ' +
str(lamb))
plt.savefig('function_Objective,_Nesterov' + chaine2 +
'_lambda_=_' + str(lamb))
if (method == 'GradianSimple'):
plt.title('function Objective, gradian simple ' + chaine1)
plt.savefig('function_Objective,_gradian_simple' + chaine2)
if (method == 'FW'):
plt.title('function Objective, FW ')
plt.savefig('function_Objective, FW')
if (method == 'OFW'):
plt.title('function Objective, Online FW ')
plt.savefig('function_Objective, Online FW')
plt.show()
return [bet, gam, supp, worked, h
] # Ajouter FinalLogLike ou l'état final de la function objective.
import numpy as np
from boutdata import collect
from boututils import moment_xyzt, file_import
from pylab import save, figure, plot, title, xlabel, ylabel, show, tight_layout
from elm_size import elm_size
path = './data'
t_array = collect('t_array', path=path)
save('t_array.dat', t_array)
p0 = collect('P0', path=path)
save('p0.dat', p0)
# n0=collect('n0', path=path)
# save('n0.dat', n0
# ti0=collect('ti0', path=path)
# save('ti0.dat', ti0)
# te0=collect('te0', path=path)
# save('te0.idl.dat', te0)
gfile = file_import('./cbm18_dens8.grid_nx68ny64.nc')
p = collect('P', path=path)
save('p.dat', p)
res = moment_xyzt(p, 'RMS', 'DC')
rmsp = res.rms
dcp = res.dc
save('rmsp.dat', rmsp)
save('dcp.dat', dcp)
elmsp = elm_size(dcp, p0, gfile, yind=32, Bbar=gfile['bmag'])
save('elmsp.dat', elmsp)
from scipy.ndimage.filters import maximum_filter, gaussian_filter,rank_filter, median_filter
from scipy.ndimage.morphology import grey_opening,grey_closing, grey_erosion
from scipy.ndimage.measurements import label,center_of_mass,maximum_position
# ===================== MANIPULATING THE IMAGE ==================
# remornalising the input.
# If needed, a nonlinear transformation can be performed changing the exponent variable
# Larger exponents suppress the low intensity region of the spectrum
print "====> Starting the manipulations...\n"
if (exponent!= 1):
print "- Nonlinear Stretching..."
# Data=((Data/float(Data.max()/theta) )**exponent*255/phi).astype(int)
Data=((Data/float(Data.max()/theta) )**exponent*255/phi).astype(int)
if(save):
pl.save("Stretching", Data)
if(opening):
print "- Morphological Opening..."
Data=grey_opening(Data, structure=Cross)
if(save):
pl.save("Opening", Data)
if(erosion):
print "- Morphological Erosion..."
Data=grey_erosion(Data, structure=Cross)
if(save):
pl.save("Erosion", Data)
if(closing):
print "- Morphological Closing..."
Data=grey_closing(Data, structure=Cross)
from scipy import arange, sin, pi, randn, zeros
import pylab as p
a = 2 # 2 volt amplitude
f = 10 # 10 Hz frequency
sigma = 0.5 # 0.5 volt standard deviation noise
# create the t and v and store them a 2D array X
t = arange(0.0, 2.0, 0.02) # an evenly sampled time array
v = a * sin(2 * f * pi * t) + sigma * randn(len(t)) # a noisy sine wave
X = zeros((len(t), 2)) # an empty output array
X[:, 0] = t # add t to the first column
X[:, 1] = v # add s to the 2nd column
p.save('data/noisy_sine.dat', X) # save the output file as ASCII
# plot the arrays t vs v and label the x-axis, y-axis and title
# save the output figure as noisy_sine.png
p.plot(t, v, 'b-')
p.xlabel('time (s)')
p.ylabel('volts (V)')
p.title('A noisy sine wave')
p.grid()
p.savefig('noisy_sine.png', dpi=150)
p.savefig('noisy_sine.eps')
p.show()
ecog_bad_channels = [
14, 30, 31, 34, 35, 36, 37, 38, 39, 40, 41, 45, 46, 48, 49, 53, 55, 57, 60,
61, 62, 63
]
probe_bad_channels = [13, 14, 15, 16, 22, 25, 29, 30]
#----------Data generation-----------------
data = lio.read_all_csc(folder,
assume_same_fs=False,
memmap=True,
memmap_folder=memap_folder,
save_for_spikedetekt=False,
channels_to_save=None,
return_sliced_data=False)
pl.save(os.path.join(memap_folder, 'B14R9_raw.npy'), data)
data_ecog = data[:64, :]
data_probe = data[64:, :]
data_probe_hp = pl.memmap(os.path.join(memap_folder, 'data_probe_hp.dat'),
dtype='int16',
mode='w+',
shape=pl.shape(data_probe))
for i in pl.arange(0, pl.shape(data_probe)[0]):
data_probe_hp[i, :] = filters.high_pass_filter(data_probe[i, :],
Fsampling=f_sampling,
Fcutoff=f_hp_cutoff)
data_probe_hp.flush()
print(i)
pl.save(os.path.join(memap_folder, 'data_probe_hp.npy'), data_probe_hp)
>>> data = zeros((3,3))
>>>#Write data:
>>> savetxt("myfile.txt", data)
>>>#Read:
>>> data = genfromtxt("myfile.txt") }}}
== Matplotlib (pylab) ==
Matplotlib provides an easy solution which seems to load data faster than read_array:
{{{#!python numbers=disable
>>> from numpy import *
>>> from pylab import load # warning, the load() function of numpy will be shadowed
>>> from pylab import save
>>> data = zeros((3,3))
>>> save('myfile.txt', data)
>>> read_data = load("myfile.txt")
# <markdowncell>
# numPy
# -----
#
# <codecell>
>>> savetxt('myfile.txt', data, fmt="%12.6G") # save to file
# <markdowncell>
#
#!/usr/bin/env python
import scipy
import pylab
from motor_comm import Motor_Comm
comm = Motor_Comm()
dt = comm.dt()
num_motor = comm.num_motor()
T = 4.0
n = T / dt
t = scipy.arange(0, 4 * n) * dt
x = scipy.zeros((t.shape[0], num_motor))
x[:, 0] = 400 * scipy.cos(2.0 * scipy.pi * t / T) + 400 * scipy.cos(
4.0 * scipy.pi * t / T)
x[:, 1] = 500 * scipy.cos(2.0 * scipy.pi * t / T) + 400 * scipy.cos(
4.0 * scipy.pi * t / T)
pylab.save('test_kine.txt', x)
mec = meccs.meccs()
sp = shape_procs.shape_procs()
data = sp.read_cs_data(base_dir + "/" + estuaryid + "_" + str(syr) + "_" +
str(sday) + "_to_" + str(eyr) + "_" + str(eday) +
".sp")
su_u = zeros(data["cs_surf_salt"].shape, float)
ds_s = zeros(data["cs_surf_salt"].shape, float)
legendstr = []
for i in range(len(s_dat)):
dat = mec.get_Hansen_Rattray(data["cs_surf_salt"][i,:], data["cs_bott_salt"][i,:], data["davg_salt"][i,:], \
data["cs_surf_hvel_dir"][i,:], data["davg_hvel_mag"][i,:], data["dt"], 24.8 * 3600)
save(out_base + data["names"][i][0] + ".hr", dat, fmt="%20.10f")
legendstr.append(data["names"][i][0])
su_u[i, :] = dat[0, :]
ds_s[i, :] = dat[1, :]
mec.hnr_plot(su_u, ds_s, "test HNR plot", legendstr)
if ctype == "river_flux":
start_time = ydhms2corie(int(syr), int(sday), 0, 15, 0)
end_time = ydhms2corie(int(eyr), int(eday), 0, 0, 0)
mr = mreader(base_dir, array([]), start_time, end_time)
data = mr.get_river_flux(base_dir, start_time, end_time, 11, 900, [0, 1],
1)
results = pl.array(results)
times = pl.array(times)
kms = ((results-6563.0)/6563.0)*2.99792458e5
pl.subplot(211)
pl.plot(times-int(times[0]),fwhm,'.')
pl.xlabel('Time (HJD)')
pl.ylabel('FWHM (Angstrom)')
pl.subplot(212)
pl.plot(times-int(times[0]),kms,'.')
pl.xlabel('Time (HJD)')
pl.ylabel('Line Velocity (km/s)')
pl.ylim(-250,250)
pl.show()
temp = pl.zeros((len(times),2),dtype='float')
for i in range(len(times)):
temp[i,0] = times[i]
temp[i,1] = kms[i]
pl.save('HaVel.dat',temp)
data_ecog_clean = pl.load(os.path.join(memap_folder,'data_ecog_clean.npy'), mmap_mode='r+')
data_ecog_mua_shaftC = pl.load(os.path.join(memap_folder,'data_ecog_mua_shaftC.npy'), mmap_mode='r+')
data_ecog_fft_norm_shaftA = pl.load(os.path.join(memap_folder, 'data_ecog_fft_norm_shaftA.npy'), mmap_mode=None)
data_ecog_fft_norm_shaftC = pl.load(os.path.join(memap_folder, 'data_ecog_fft_norm_shaftC.npy'), mmap_mode=None)
phases_all_shaftA = pl.load(os.path.join(memap_folder, 'phases_all_shaftA.npy'), mmap_mode=None)
phases_all_shaftC = pl.load(os.path.join(memap_folder, 'phases_all_shaftC.npy'), mmap_mode=None)
data = pl.load(os.path.join(memap_folder,'B14R9_raw.npy'), mmap_mode='r+')
#----------Data generation-----------------
data = lio.read_all_csc(folder, assume_same_fs=False, memmap=True, memmap_folder=memap_folder, save_for_spikedetekt=False, channels_to_save=None, return_sliced_data=False)
pl.save(os.path.join(memap_folder, 'B14R9_raw.npy'), data)
data_ecog = data[:64,:]
data_probe = data[64:,:]
data_probe_hp = pl.memmap(os.path.join(memap_folder,'data_probe_hp.dat'), dtype='int16', mode='w+', shape=pl.shape(data_probe))
for i in pl.arange(0, pl.shape(data_probe)[0]):
data_probe_hp[i,:] = filters.high_pass_filter(data_probe[i,:], Fsampling=f_sampling, Fcutoff=f_hp_cutoff)
data_probe_hp.flush()
print(i)
pl.save(os.path.join(memap_folder, 'data_probe_hp.npy'), data_probe_hp)
shape_data_ss = (pl.shape(data_ecog)[0], pl.shape(data_ecog)[1]/int(f_sampling/f_subsample))
data_ecog_lp_ss = pl.memmap(os.path.join(memap_folder, 'data_ecog_lp_ss.dat'), dtype='int16', mode='w+', shape=shape_data_ss)
# Save filenames of matching views
file = open(query_files[1] % (i, "match"), "w")
for (index, score) in top_n:
file.write("%s %f\n" %
(reference_files[0] % reference_files[2][index], score))
return M
def plot_confusion(M):
# Show full score matrix
pylab.pcolor(numpy.array(M))
pylab.colorbar()
pylab.show()
# Tuples describing file names (image format, output format, range)
run1_files = ("/u/kosecka/research/run1/%06uL.png", "run1_%06uL.%s",
range(2400, 3401))
run2_files = ("/u/kosecka/research/run2/%06uL.png", "run2_%06uL.%s",
range(2200, 3201))
# run 1 in vocabulary tree, run 2 used as queries
M = match_runs(run1_files, run2_files)
pylab.save('run1vt_run2q.mat', M)
#plot_confusion(M)
# run 2 in vocabulary tree, run 1 used as queries
M = match_runs(run2_files, run1_files)
pylab.save('run2vt_run1q.mat', M)
#plot_confusion(M)
"%02d" % (init_time.day),
"%02d" % (init_time.hour),
"%02d" % (init_time.minute)
])
if not os.path.exists('dbase/%s' % directory):
print 'directory %s do not exist, creating directoy and downloading files' % directory
os.makedirs('dbase/%s' % directory)
# VSO download
client = vso.VSOClient()
qr = client.query(vso.attrs.Time(itime, etime),
vso.attrs.Instrument('hmi'),
vso.attrs.Physobs('intensity'))
nrec = qr.num_records()
save("recnums/%s.txt" % directory, nrec)
print nrec
res = client.get(qr, path='./tmp/{file}.fits').wait()
listOfFiles = os.listdir('./tmp')
for f in listOfFiles:
os.system("mv ./tmp/%s ./dbase/%s" % (f, directory))
save("recnums/%s.txt" % directory, nrec)
else:
print "Directory %s exists" % directory
#load number of records
snrec = load("recnums/%s.txt.npy" % directory)
nfiles = len([name for name in os.listdir("./dbase/%s" % directory)])
if not nfiles == snrec:
print 'Number of files incorrect: downloading files to %s nrec = %d...nfiles = %d' % (
directory, snrec, nfiles)
for i in range(len(date)):
lt = x < 4687
gt = x > 4686
flux.append((pf.getdata(ff[i])[lt*gt]).sum())
flux = pl.array(flux)
temp = []
temp.append(date)
temp.append(phase)
temp.append(flux)
pl.save('HeIIlightcurve.dat',pl.array(temp).transpose())
lt = phase < 7.9
date = date[lt]
flux = pl.array(flux)[lt]
phase = pl.array(phase)[lt]
# flatten lightcurve using fourier method
fft = sci.fft(flux)
fft[0:4] = 0.0
fft[-4:] = 0.0
flux = sci.ifft(fft)
f,a = ast.signal.dft(date,flux,0,4000,1)
pl.figure()
pl.subplot(211)
ew = pl.array(ew[:-2])
center = pl.array(center[:-2])
print len(ew),len(center),len(HJD)
#X = pl.load('rv.dat')
#ew = X[:,0]
pl.figure()
pl.subplot(311)
pl.title('Line Center')
pl.plot(center,'o')
pl.subplot(312)
pl.plot(HJD,ew,'go')
pl.title('Equivalent Width')
pl.subplot(313)
f,a = ast.signal.dft(HJD,ew,0,4000,1)
pl.plot(f,a)
pl.title('Equivalent Width FT')
pl.show()
temp = []
temp.append(HJD)
temp.append(ew)
temp.append(center)
pl.save('EW.dat',pl.array(temp).transpose())
fig.imshow(clrs, interpolation='nearest')
pl.xlim(0, pl.xlim()[1])
pl.ylim(pl.ylim()[0], 0)
coords = (coords[(coords[:, 0] > 5) * \
(coords[:, 0] < stack.shape[0] - 5) *\
(coords[:, 1] > 5) * \
(coords[:, 1] < stack.shape[1] - 5)])
print("Found %d good windows away from the edges" % len(coords))
for c in coords:
pl.plot(c[1], c[0], 'wo', alpha=0.3)
pl.title("gaussian std %d, threshold %.1f, labels %d" %
(GS, thr, np.sum(goodwindows)))
pl.savefig(args[0].replace(".npy", "_selectedwindows.pdf"))
if options.showme: pl.show()
pl.close()
# coords = np.array([coords[:, 1], coords[:, 0]])
pl.save(args[0].replace(".npy", "_coords.npy"), coords[:, 1::-1])
pl.save(args[0].replace(".npy", "_mask.npy"), mask)
# print (mask)
# for i in range(labels.max()+1):
# if i in labels:
# pl.figure()
# pl.imshow(mask[:i].sum(axis=0), interpolation='nearest',
# cmap='gist_gray')
# pl.savefig("mask.%04d.png"%i)
# pl.close('all')
def showVectorDisplacements():
global testImage, croppedRefImage, u, v, valid, q1, umean, vmean, x, y, sxyVar, wxyVar, goodvectorsVar
from scipy import where, compress, logical_and, median, logical_or, nan
from pylab import resize, transpose, quiver, title, show, find, imshow, hist, figure, clf, draw, save, load, xlabel, ylabel, flipud
mxy = 3
wxy = int(wxyVar.get())
sxy = int(sxyVar.get())
goodvectors = float(goodvectorsVar.get())
#process to find PIV-style displacements
x, y, u, v, q1, valid = simplepiv(croppedRefImage, testImage, wxy, mxy,
sxy)
good = where(logical_and(q1 > goodvectors, valid > 0), True, False)
umean = median(compress(good.flat, u.flat))
vmean = median(compress(good.flat, v.flat))
u = where(logical_or(q1 < goodvectors, valid < 0), 0, u)
v = where(logical_or(q1 < goodvectors, valid < 0), 0, v)
u = u - umean
v = v - vmean
save('vecx.out', x)
save('vecy.out', y)
save('vecu.out', u)
save('vecv.out', v)
save('vecq1.out', q1)
save('vecvalid.out', valid)
u = flipud(u)
v = -flipud(v)
quiver(x, y, u, v)
title('Vector displacements')
xlabel('Pixels')
ylabel('Pixels')
show()
return
mkdir_p(os.path.join(outpath, 'pdb'))
mkdir_p(os.path.join(outpath, 'aln'))
mkdir_p(os.path.join(outpath, 'adist'))
#erase files
with open(os.path.join(outpath, 'insertCounts'), 'wt') as f:
pass
with open(os.path.join(outpath, 'deletecounts'), 'wt') as f:
pass
with open(os.path.join(outpath, 'unresolvedcounts'), 'wt') as f:
pass
for name in fullalnseqs.keys():
if not os.path.exists(os.path.join(distpath, name + '.npy')):
print(name, "Skipping: No coords")
continue
print(name)
adist = plotContacts(name)
pylab.subplots_adjust(bottom=0.05, right=0.95, top=0.95, left=0.05)
pylab.figure(1)
pylab.savefig(os.path.join(outpath, 'pdb/{}.png'.format(name)))
pylab.close()
pylab.figure(2)
pylab.savefig(os.path.join(outpath, 'aln/{}.png'.format(name)))
pylab.close()
pylab.save(os.path.join(outpath, 'adist/{}'.format(name)), adist)
lines['Hb'] = Hb
lines['HeII'] = HeII
lines['Cont'] = continuum
time = time[:-2]
# save the lightcurves to file
for line in ['Ha','Hb','HeII','Cont']:
#for line in ['HeII']:
lc = pl.array(lines[line])[:-2]
#lcmean = lc.mean()
#lc = lc - lcmean
##temp = pl.zeros((len(lc),3),dtype='float')
## flatten lightcurves by fitting 11th order poly to them
#tmean = time.mean()
#p = pl.polyfit(time-tmean,lc,13)
#yy = pl.polyval(p,time-tmean)
#print yy
temp = []
temp.append(time)
temp.append(lc)
#temp.append(lc-yy)
#for i in range(len(lc)):
#temp[i,0] = time[i]
#temp[i,1] = lc[i]
#temp
pl.save('speclc_%s.dat'%line,pl.array(temp).transpose(),fmt='%1.6f')
import sciris as sc
import pylab as pl
class Animal(sc.prettyobj):
def __init__(self, name, mass, velocity):
self.name = name
self.mass = mass
self.velocity = velocity
def energy(self):
return 0.5 * self.mass * self.velocity**2
# Create animals
worm = Animal(name='worm', mass=0.002,
velocity=0.01) # shorthand: Animal('worm', 0.002, 0.01)
pigeon = Animal(name='pigeon', mass=0.086, velocity=9.6)
cat = Animal(name='cat', mass=7.3, velocity=4.4)
animals = [worm, pigeon, cat]
# Save and load animals
pl.save('animals.npy', animals) # file must end .npy (for numpy)
saved_animals = pl.load('animals.npy')
# Check it worked
print(saved_animals[0])
def generate_data(a_b,xl,type):
y=[]
execution_time=[]
particle = Spheroid(m,a_b,type)
particle.set_xl(xl)
id = str(a_b) + " " + str(xl) + " " + str(type)
for i in range(n_min,n_max,2):
nmax = i
print nmax
start = time.time()
svm = SpheroidalSVM(particle,nmax)
b_sca = svm.getSolution(TMInputWave(alpha))[0]
C_ext = getCext(particle, alpha, b_sca, nmax)[0]
C_sca = getCsca(particle, b_sca, nmax)[0]
delta=(C_ext-C_sca)/(C_ext+C_sca)
execution_time.append(time.time() - start)
y.append(delta)
y= np.fabs(y)
save("svm_delta"+id,y)
save("svm_time"+id,execution_time)
y=[]
execution_time=[]
for i in range(n_min,n_max,2):
nmax = i
print nmax
start = time.time()
ebcm = SpheroidalEBCM(particle,nmax)
b_sca = ebcm.getMatrixSolution(TMInputWave(alpha))[0]
C_ext = getCext(particle, alpha, b_sca, nmax)[0]
C_sca = getCsca(particle, b_sca, nmax)[0]
delta=(C_ext-C_sca)/(C_ext+C_sca)
execution_time.append(time.time() - start)
y.append(delta)
y= np.fabs(y)
save("ebcm_m_delta"+id,y)
save("ebcm_m_time"+id,execution_time)
y=[]
execution_time=[]
for i in range(n_min,n_max,2):
nmax = i
print nmax
start = time.time()
ebcm = SpheroidalEBCM(particle,nmax)
b_sca = ebcm.getSolution(TMInputWave(alpha))[0]
C_ext = getCext(particle, alpha, b_sca, nmax)[0]
C_sca = getCsca(particle, b_sca, nmax)[0]
delta=(C_ext-C_sca)/(C_ext+C_sca)
execution_time.append(time.time() - start)
y.append(delta)
y= np.fabs(y)
save("ebcm_delta"+id,y)
save("ebcm_time"+id,execution_time)
y=[]
execution_time=[]
spectre = exp(-(e / 200)**2 - (t / lgt / .6)**2) * 30
pics = [(52., 60., 2.5, 10000.), (52., 140., 1., 10000.), (52., 150., 1., .5),
(125., 160., 1., .3), (125., 170., 1., .2), (125., 180., 1., .1),
(222., 190., 1., .07), (422., 200., 1., .05), (52., 340., 1., -10000.),
(8., 350., 1., -5.), (2., 360., 1., -1.), (1., 370., 1., -.2),
(.1, 380., 1., -.1), (222., 390., 1., .07), (22., 400., 1., -.8)]
for pds, moy, sig, tau in pics:
print(pds, moy, sig, tau)
spectre += pds * exp(-.5 * (e - moy)**2 / sig**2) * exp(-t / tau / lgt)
pics = [(52., 260., 1., .2), (52., 275., 1., .08), (1., 290., 1., .1)]
for pds, moy, sig, tau in pics:
print(pds, moy, sig, tau)
spectre += pds * exp(-.5 *
(e - moy)**2 / sig**2) * (1.1 + sin(-t / tau / lgt))
spectre = poisson(spectre)
subplot(121)
semilogy(te, spectre.sum(0))
subplot(122)
semilogy(tt, spectre.sum(1))
tb = c_[tt, spectre].T
# df=pd.DataFrame(c_[tt,spectre])
# df.to_csv("jouet_s2.csv",sep="\t",header=False,index=False)
# savetxt("jouet_s2.csv",c_[tt,spectre],fmt='%.6e'+' \t%i'*lge, delimiter='\t ')
pl.save('jouet_s2_dict.bin', {"ta": 1., "spectre": tb})
show()
def save(self, filename="/dev/stdout"):
"""Dumps detector object to file"""
pylab.save(filename, self.data, fmt='%g')
def __init__(
self,
features,
nfeatures,
nside=16,
include_haversine=False,
galactic_mask=None,
affinity="euclidean",
scaler=preprocessing.StandardScaler(),
file_affinity="",
verbose=False,
save_affinity=False,
feature_weights=None,
):
"""
-features: list of features to cluster
-nfeatures
"""
self._nside = nside
self._nfeat = nfeatures
if galactic_mask is None:
self.galactic_mask = np.bool_(pl.ones_like(features[0]))
else:
self.galactic_mask = galactic_mask
features[0] = features[0][galactic_mask]
features[1] = features[1][galactic_mask]
if self._nfeat > 1:
assert features[0].shape[0] == features[1].shape[0]
self._npix = features[0].shape[0] # hp.nside2npix(nside)
else:
self._npix = features.shape[0]
if feature_weights is None:
feature_weights = pl.ones(self._nfeat)
self.verbose = verbose
self._X = pl.zeros((self._npix, self._nfeat))
if self._nfeat == 1:
features = [features]
for i, x in zip(range(self._nfeat), features):
self._X[:, i] = x
# Standard rescaling of all the features
if scaler is not None:
self._X = scaler.fit_transform(self._X)
for i in range(self._nfeat):
self._X[:, i] *= feature_weights[i]
self.estimate_affinity(affinity, file_affinity)
self._has_angles = False
if include_haversine:
self._has_angles = True
self.estimate_haversine()
self._Affinity = pairwise_kernels(self._distance_matr,
metric="precomputed")
if save_affinity:
pl.save(file_affinity, self._Affinity)
results = pl.array(results)
times = pl.array(times)
kms = ((results-4686.0)/4686.0)*2.99792458e5
pl.subplot(211)
pl.plot(times-int(times[0]),fwhm,'.')
pl.xlabel('Time (HJD)')
pl.ylabel('FWHM (Angstrom)')
pl.subplot(212)
pl.plot(times-int(times[0]),kms,'.')
pl.xlabel('Time (HJD)')
pl.ylabel('Line Velocity (km/s)')
pl.ylim(-400,400)
pl.show()
temp = pl.zeros((len(times),2),dtype='float')
for i in range(len(times)):
temp[i,0] = times[i]
temp[i,1] = kms[i]
pl.save('HeIIVel.dat',temp)
def save_it_all():
from pylab import save
save((train_string, test_string), 'wiki_letters_2G')