def intersection(self,ray) :
cv = self.placement.location+self.placement.orientation*self.radcurv
dv = ray.p0 - self.placement.orientation*self.radcurv - self.placement.location
a = 1
b = 2*pl.linalg.dot(ray.d,dv)
c = pl.linalg.dot(dv,dv)-self.radcurv**2
qs = b**2-4*a*c
if qs == 0 :
lam = -b/(2*a)
elif qs < 0 :
lam = None
else :
lamp = (-b+pl.sqrt(b**2-4*a*c))/(2*a)
lamn = (-b-pl.sqrt(b**2-4*a*c))/(2*a)
pd = pl.linalg.norm(ray.propagate(lamp)-ray.p0)
nd = pl.linalg.norm(ray.propagate(lamn)-ray.p0)
# lam = min(lamp,lamn)
if self.radcurv > 0 :
lam = min(lamp,lamn)
elif self.radcurv < 0 :
lam = max(lamp,lamn)
# assign intersection
ray.p1 = ray.propagate(lam)
def rank_by_distance_bhatt(self, qkeys, ikeys, rkeys, dists):
"""
::
Reduce timbre-channel distances to ranks list by ground-truth key indices
Bhattacharyya distance on timbre-channel probabilities and Kullback distances
"""
# timbre-channel search using pre-computed distances
ranks_list = []
t_keys, t_lens = self.get_adb_lists(0)
rdists=pylab.ones(len(t_keys))*float('inf')
qk = self._get_probs_tc(qkeys)
for i in range(len(ikeys[0])): # number of include keys
ikey=[]
dk = pylab.zeros(self.timbre_channels)
for t_chan in range(self.timbre_channels): # timbre channels
ikey.append(ikeys[t_chan][i])
try:
# find dist of key i for query
i_idx = rkeys[t_chan].index( ikey[t_chan] ) # dataset include-key match
# the reduced distance function in include_keys order
# distance is Bhattacharyya distance on probs and dists
dk[t_chan] = dists[t_chan][i_idx]
except:
print "Key not found in result list: ", ikey, "for query:", qkeys[t_chan]
raise error.BregmanError()
rk = self._get_probs_tc(ikey)
a_idx = t_keys.index( ikey[0] ) # audiodb include-key index
rdists[a_idx] = distance.bhatt(pylab.sqrt(pylab.absolute(dk)), pylab.sqrt(pylab.absolute(qk*rk)))
#search for the index of the relevant keys
rdists = pylab.absolute(rdists)
sort_idx = pylab.argsort(rdists) # Sort fields into database order
for r in self.ground_truth: # relevant keys
ranks_list.append(pylab.where(sort_idx==r)[0][0]) # Rank of the relevant key
return ranks_list, rdists
def f(x, t):
# for now masses just = 1.0
# the 4.0 only works for 2D
N = len(x) / 4
xdot = pl.array([])
for i in range(N):
temp = 0.0
for j in range(N):
if i == j:
continue
temp += -(x[2 * N + i] - x[2 * N + j]) / (
pl.sqrt((x[2 * N + i] - x[2 * N + j]) ** 2 + (x[3 * N + i] - x[3 * N + j]) ** 2) ** 3
)
xdot = pl.append(xdot, temp)
for i in range(N):
temp = 0.0
for j in range(N):
if i == j:
continue
temp += -(x[3 * N + i] - x[3 * N + j]) / (
pl.sqrt((x[2 * N + i] - x[2 * N + j]) ** 2 + (x[3 * N + i] - x[3 * N + j]) ** 2) ** 3
)
xdot = pl.append(xdot, temp)
for i in range(N):
xdot = pl.append(xdot, x[i])
for i in range(N):
xdot = pl.append(xdot, x[N + i])
print("len xdot is: " + str(len(xdot)))
return xdot
def displayData(X):
print "Visualizing"
m, n = X.shape
width = round(sqrt(n))
height = width
display_rows = int(floor(sqrt(m)))
display_cols = int(ceil(m/display_rows))
print "Cell width:", width
print "Cell height:", height
print "Display rows:", display_rows
print "Display columns:", display_cols
display = zeros((display_rows*height,display_cols*width))
# Iterate through the training sets, reshape each one and populate
# the display matrix with the letter matrixes.
for xrow in range(0, m):
rowindex = divide(xrow, display_cols)
columnindex = remainder(xrow, display_cols)
rowstart = int(rowindex*height)
rowend = int((rowindex+1)*height)
colstart = int(columnindex*width)
colend = int((columnindex+1)*width)
display[rowstart:rowend, colstart:colend] = X[xrow,:].reshape(height,width).transpose()
imshow(display, cmap=get_cmap('binary'), interpolation='none')
# Show plot without blocking
draw()
def calculateFDunc(self):
#Calculates the uncertainty of the FFT according to:
# - J. M. Fornies-Marquina, J. Letosa, M. Garcia-Garcia, J. M. Artacho, "Error Propagation for the transformation of time domain into frequency domain", IEEE Trans. Magn, Vol. 33, No. 2, March 1997, pp. 1456-1459
#return asarray _tdData
#Assumes tha the amplitude of each time sample is statistically independent from the amplitude of the other time
#samples
# Calculates uncertainty of the real and imaginary part of the FFT and ther covariance
unc_E_real = []
unc_E_imag = []
cov = []
for f in self.getfreqs():
unc_E_real.append(py.sum((py.cos(2*py.pi*f*self._tdData.getTimes())*self._tdData.getUncEX())**2))
unc_E_imag.append(py.sum((py.sin(2*py.pi*f*self._tdData.getTimes())*self._tdData.getUncEX())**2))
cov.append(-0.5*sum(py.sin(4*py.pi*f*self._tdData.getTimes())*self._tdData.getUncEX()**2))
unc_E_real = py.sqrt(py.asarray(unc_E_real))
unc_E_imag = py.sqrt(py.asarray(unc_E_imag))
cov = py.asarray(cov)
# Calculates the uncertainty of the modulus and phase of the FFT
unc_E_abs = py.sqrt((self.getFReal()**2*unc_E_real**2+self.getFImag()**2*unc_E_imag**2+2*self.getFReal()*self.getFImag()*cov)/self.getFAbs()**2)
unc_E_ph = py.sqrt((self.getFImag()**2*unc_E_real**2+self.getFReal()**2*unc_E_imag**2-2*self.getFReal()*self.getFImag()*cov)/self.getFAbs()**4)
t=py.column_stack((self.getfreqs(),unc_E_real,unc_E_imag,unc_E_abs,unc_E_ph))
return self.getcroppedData(t)
def ICeuklid_to_ICcircle(IC):
"""
converts from IC in euklidean space to IC in circle parameters (rotational invariant).
The formats are:
IC_euklid: [x, y, z, vx, vy, vz]
IC_circle: [y, vy, |v|, |l|, phiv], where |v| is the magnitude of CoM velocity, |l|
is the distance from leg1 (assumed to be at [0,0,0]) to CoM, and phiv the angle
of the velocity in horizontal plane wrt x-axis
*NOTE* for re-conversion, the leg position is additionally required
:args:
IC (6x float): the initial conditions in euklidean space
:returns:
IC (5x float): the initial conditions in circular coordinates
"""
x,y,z,vx,vy,vz = IC
v = sqrt(vx**2 + vy**2 + vz**2)
l = sqrt(x**2 + y**2 + z**2)
#phiv = arctan2(vz, vx)
#phiv = arctan2(-vz, vx)
phiv = -arctan2(-vz, vx)
#phix = arctan2(-z, -x)
phix = arctan2(z, -x)
# warnings.warn('TODO: fix phi_x (add)')
# print "phix:", phix * 180 / pi
return [y, vy, v, l, phiv + phix]
def renormalize(x_unpurt,x_before,x_purt,epsilon,N):
# BEFORE ANYTHING: make sure particles near boundaries are shuffeled into places where where the
# seam is not between any purturbed and fudicial trajectories.
x_unpurt,x_purt = shuff(x_unpurt,x_purt,N)
# The trajectory we are going to be returning is going to be the new one for the next run. lets
# call it
x_new = pl.copy(x_unpurt)
# copied it because we are going to add the small amounts to it to purturb it.
# lets find a vector pointing in the direction of the trajectories path. For this we need the
# fiducual point at t-dt, which is given to us in the function as x_before. find the vector
# between x_before and x_unpurt
traj_vec = x_unpurt-x_before
# normalize it
traj_vec = traj_vec/pl.sqrt(pl.dot(traj_vec,traj_vec))
print('traj_vec magnitude (should be 1): ' + str(pl.sqrt(pl.dot(traj_vec,traj_vec))))
# Now lets see how close the vector pointing from the fidicial to the perturbed trajectorie is
# to orthogonal with the trajectory... should get closer to 1 as we check more because it should
# be aligning itself with the axis of greatest expansion and that should be orthogonal.
# First normalize the difference vector
diff_vec = x_unpurt - x_purt
# normalize it
diff_vec = diff_vec/pl.sqrt(pl.dot(diff_vec,diff_vec))
print('diff_vec magnitude (should be 1): ' + str(pl.sqrt(pl.dot(diff_vec,diff_vec))))
print('normalized(x_unpurt-x_purt)dot(traj_vec) (should get close to 0): '+ str(pl.dot(diff_vec,traj_vec)))
# for now lets just return a point moved back along the difference vector. no gram shmidt or
# anything.
return x_new + epsilon*diff_vec
def data_to_ch(data):
ch = {}
for ch_ind in range(1, 97):
ch[ch_ind] = {}
ch[ch_ind]["bl"] = data[ch_ind]["blanks"]
ch[ch_ind]["bl_mu"] = pl.mean(ch[ch_ind]["bl"])
ch[ch_ind]["bl_sem"] = pl.std(ch[ch_ind]["bl"]) / pl.sqrt(len(ch[ch_ind]["bl"]))
for ind in sorted(data[ch_ind].keys()):
if ind != "blanks":
k = ind[0]
if k not in ch[ch_ind]:
ch[ch_ind][k] = {}
ch[ch_ind][k]["fr"] = []
ch[ch_ind][k]["fr_mu"] = []
ch[ch_ind][k]["fr_sem"] = []
ch[ch_ind][k]["pos_y"] = []
ch[ch_ind][k]["dprime"] = []
ch[ch_ind][k]["fr"].append(data[ch_ind][ind]["on"])
ch[ch_ind][k]["fr_mu"].append(pl.mean(data[ch_ind][ind]["on"]))
ch[ch_ind][k]["fr_sem"].append(pl.std(data[ch_ind][ind]["on"]) / pl.sqrt(len(data[1][ind]["on"])))
ch[ch_ind][k]["pos_y"].append(ind[2])
# print ch[ch_ind][k]['pos_y']
# print pl.std(data[ch_ind][ind]['on'])
ch[ch_ind][k]["dprime"].append(
(pl.mean(data[ch_ind][ind]["on"]) - ch[ch_ind]["bl_mu"])
/ ((pl.std(ch[ch_ind]["bl"]) + pl.std(data[ch_ind][ind]["on"])) / 2)
)
# print ch[ch_ind]['OSImage_5']['pos_y']
return ch
def ICcircle_to_ICeuklid(IC):
"""
converts from IC in cirle parameters to IC in euklidean space (rotational invariant).
The formats are:
IC_euklid: [x, y, z, vx, vy, vz]
IC_circle: [y, vy, |v|, |l|, phiv], where |v| is the magnitude of CoM velocity, |l|
is the distance from leg1 (assumed to be at [0,0,0]) to CoM, and phiv the angle
of the velocity in horizontal plane wrt x-axis
*NOTE* for re-conversion, the leg position is additionally required, assumed to be [0,0,0]
Further, it is assumed that the axis foot-CoM points in x-axis
:args:
IC (5x float): the initial conditions in circular coordinates
:returns:
IC (6x float): the initial conditions in euklidean space
"""
y, vy, v, l, phiv = IC
z = 0
xsq = l**2 - y**2
if xsq < 0:
raise RuntimeError('Error in initial conditions: y > l!')
x = -sqrt(xsq)
vhsq = v**2 - vy**2
if vhsq < 0:
raise RuntimeError('Error in initial conditions: |vy| > |v|!')
v_horiz = sqrt(vhsq)
vx = v_horiz * cos(phiv)
#vz = v_horiz * sin(phiv)
vz = v_horiz * sin(phiv)
return [x, y, z, vx, vy, vz]
def haversine (latlong1, latlong2, r):
deltaLatlong = latlong1 - latlong2
dLat = deltaLatlong[0]
dLon = deltaLatlong[1]
lat1 = latlong1[0]
lat2 = latlong2[0]
a = (sin (dLat/2) * sin (dLat/2) +
sin (dLon/2) * sin (dLon/2) * cos (lat1) * cos (lat2))
c = 2 * arctan2 (sqrt (a), sqrt (1-a))
d = r * c
# initial bearing
y = sin (dLon) * cos (lat2)
x = (cos (lat1)*sin (lat2) -
sin (lat1)*cos (lat2)*cos (dLon))
b1 = arctan2 (y, x);
# final bearing
dLon = -dLon
dLat = -dLat
tmp = lat1
lat1 = lat2
lat2 = tmp
y = sin (dLon) * cos (lat2)
x = (cos (lat1) * sin (lat2) -
sin (lat1) * cos (lat2) * cos (dLon))
b2 = arctan2 (y, x)
b2 = mod ((b2 + pi), 2*pi)
return (d, b1, b2)
def __calculate__(self):
global USE_IDENTITY_LINE
sd1 = (self.signal_plus - self.signal_minus) / pl.sqrt(2)
if USE_IDENTITY_LINE:
return pl.sqrt(pl.sum((sd1 ** 2)) / len(self.signal_plus))
else:
return pl.sqrt(pl.var(sd1))
def simple_hierarchical_data(n):
""" Generate data based on the simple one-way hierarchical model
given in section 3.1.1::
y[i,j] | alpha[j], sigma^2 ~ N(alpha[j], sigma^2) i = 1, ..., n_j, j = 1, ..., J;
alpha[j] | mu, tau^2 ~ N(mu, tau^2) j = 1, ..., J.
sigma^2 ~ Inv-Chi^2(5, 20)
mu ~ N(5, 5^2)
tau^2 ~ Inv-Chi^2(2, 10)
Parameters
----------
n : list, len(n) = J, n[j] = num observations in group j
"""
inv_sigma_sq = mc.rgamma(alpha=2.5, beta=50.0)
mu = mc.rnormal(mu=5.0, tau=5.0 ** -2.0)
inv_tau_sq = mc.rgamma(alpha=1.0, beta=10.0)
J = len(n)
alpha = mc.rnormal(mu=mu, tau=inv_tau_sq, size=J)
y = [mc.rnormal(mu=alpha[j], tau=inv_sigma_sq, size=n[j]) for j in range(J)]
mu_by_tau = mu * pl.sqrt(inv_tau_sq)
alpha_by_sigma = alpha * pl.sqrt(inv_sigma_sq)
alpha_bar = alpha.sum()
alpha_bar_by_sigma = alpha_bar * pl.sqrt(inv_sigma_sq)
return vars()
def sample(self, model, evidence):
g = evidence['g']
h = evidence['h']
C = evidence['C']
z = evidence['z']
shot_id = evidence['shot_id']
noise_proportion = evidence['noise_proportion']
observation_var_g = evidence['observation_var_g']
observation_var_h = evidence['observation_var_h']
canopy_cover = model.known_params['canopy_cover']
z_min = model.known_params['z_min']
z_max = model.known_params['z_max']
prior_p = model.hyper_params['T']['p']
N = len(z)
T = zeros(N)
noise_rv = stats.uniform(z_min, z_max - z_min)
min_index = min(z.index)
for i in shot_id.index:
l = zeros(3)
index = i-min_index
shot_index = shot_id[i]-min(shot_id)
l[0] = noise_proportion*noise_rv.pdf(z[i])
g_norm = stats.norm(g[shot_index], sqrt(observation_var_g))
C_i = canopy_cover[C[shot_index]]
l[1] = (1-noise_proportion)*(1-C_i)*g_norm.pdf(z[i])
h_norm = stats.norm(h[shot_index] + g[shot_index], sqrt(observation_var_h))
if z[i] > g[shot_index]+3:
l[2] = (1-noise_proportion)*(C_i)*h_norm.pdf(z[i])
p = l/sum(l)
T[index] = Categorical(p).rvs()
return T
def plot_track_props(tracks, nx, ny, len_cutoff=20):
pl.ioff()
wdist = wraparound_dist(nx, ny)
val_fig = pl.figure()
area_fig = pl.figure()
psn_fig = pl.figure()
delta_vals = []
delta_dists = []
for tr in tracks:
if len(tr) < len_cutoff:
continue
idxs, regs = zip(*tr)
delta_vals.extend([abs(regs[idx].val - regs[idx + 1].val) for idx in range(len(regs) - 1)])
dists = [wdist(regs[i].loc, regs[i + 1].loc) for i in range(len(regs) - 1)]
delta_dists.extend([abs(dists[idx] - dists[idx + 1]) for idx in range(len(dists) - 1)])
pl.figure(val_fig.number)
pl.plot(idxs, [reg.val for reg in regs], "s-", hold=True)
pl.figure(area_fig.number)
pl.semilogy(idxs, [reg.area for reg in regs], "s-", hold=True)
pl.figure(psn_fig.number)
pl.plot(idxs[:-1], dists, "s-", hold=True)
pl.figure(val_fig.number)
pl.savefig("val_v_time.pdf")
pl.figure(area_fig.number)
pl.savefig("area_v_time.pdf")
pl.figure(psn_fig.number)
pl.savefig("psn_v_time.pdf")
pl.figure()
pl.hist(delta_vals, bins=pl.sqrt(len(delta_vals)))
pl.savefig("delta_vals.pdf")
pl.figure()
pl.hist(delta_dists, bins=pl.sqrt(len(delta_dists)))
pl.savefig("delta_dists.pdf")
pl.close("all")
def render_network(A):
[L, M] = shape(A)
sz = int(sqrt(L))
buf = 1
A = asarray(A)
if floor(sqrt(M)) ** 2 != M:
m = int(sqrt(M / 2))
n = M / m
else:
m = int(sqrt(M))
n = m
array = -ones([buf + m * (sz + buf), buf + n * (sz + buf)], "d")
k = 0
for i in range(m):
for j in range(n):
clim = max(abs(A[:, k]))
x_offset = buf + i * (sz + buf)
y_offset = buf + j * (sz + buf)
array[x_offset : x_offset + sz, y_offset : y_offset + sz] = reshape(A[:, k], [sz, sz]) / clim
k += 1
return array
def haversine(location1, location2=None): # calculates great circle distance
__doc__ = """Returns the great circle distance of the given
coordinates.
INPUT: location1 = ((lat1, lon1), ..., n(lat1, lon1))
*location2 = ((lat2, lon2), ..., n(lat2, lon2))
*if location2 is not given a square matrix of distances
for location1 will be put out
OUTPUT: distance in km
(dist1 ... ndist
: :
ndist1 ... ndist)
shape will depend on the input
METHOD: a = sin(dLat / 2) * sin(dLat / 2) +
sin(dLon / 2) * sin(dLon / 2) *
cos(lat1) * cos(lat2)
c = 2 * arctan2(sqrt(a), sqrt(1 - a))
d = R * c
where R is the earth's radius (6371 km)
and d is the distance in km"""
from itertools import product, combinations
from pylab import deg2rad, sin, cos, arctan2, \
meshgrid, sqrt, array, arange
if location2:
location1 = array(location1, ndmin=2)
location2 = array(location2, ndmin=2)
elif location2 is None:
location1 = array(location1, ndmin=2)
location2 = location1.copy()
# get all combinations using indicies
ind1 = arange(location1.shape[0])
ind2 = arange(location2.shape[0])
ind = array(list(product(ind1, ind2)))
# using combination inds to get lats and lons
lat1, lon1 = location1[ind[:,0]].T
lat2, lon2 = location2[ind[:,1]].T
# setting up variables for haversine
R = 6371.
dLat = deg2rad(lat2 - lat1)
dLon = deg2rad(lon2 - lon1)
lat1 = deg2rad(lat1)
lat2 = deg2rad(lat2)
# haversine formula
a = sin(dLat / 2) * sin(dLat / 2) + \
sin(dLon / 2) * sin(dLon / 2) * \
cos(lat1) * cos(lat2)
c = 2 * arctan2(sqrt(a), sqrt(1 - a))
d = R * c
# reshape accodring to the input
D = d.reshape(location1.shape[0], location2.shape[0])
return D
def measureDistance(lat1, lon1, lat2, lon2):
R = 6383.137 # Radius of earth at Chajnantor aprox. in KM
dLat = (lat2 - lat1) * np.pi / 180.
dLon = (lon2 - lon1) * np.pi / 180.
a = pl.sin(dLat/2.) * pl.sin(dLat/2.) + pl.cos(lat1 * np.pi / 180.) * pl.cos(lat2 * np.pi / 180.) * pl.sin(dLon/2.) * pl.sin(dLon/2.)
c = 2. * atan2(pl.sqrt(a), pl.sqrt(1-a))
d = R * c
return d * 1000. # meters
def exhaustVelocity( energyDensity=None, pressureOut=None, pressureIn=const_atmosphericPressure*25, temperature=3500, kappa=1.666666, molarMass=2 ): if (energyDensity!=None): # from kinetic energy return pylab.sqrt( 2*energyDensity ) else: # lavalNozzle adiabatic expansion http://en.wikipedia.org/wiki/De_Laval_nozzle gamma = (kappa)/(kappa-1) ExpansionTerm = 1.0 if (( pressureOut != None ) ): ExpansionTerm = (1.0 - (pressureOut/pressureIn)**(1/gamma) ) return pylab.sqrt(2000.0*const_universalGas*temperature*gamma*ExpansionTerm/molarMass)
def pkj1pk(self, r, z=0):
"""
integral of the power spectrum*k over j1
"""
return (
M.sqrt(M.pi / 2.0)
/ r
* self.besselInt.besselInt(lambda k: self.delta(k / r, z) / M.sqrt(k), 1.5, self.besselN, self.besselh)
)
def xyamb(xytab,qu,xyout=''):
mytb=taskinit.tbtool()
if not isinstance(qu,tuple):
raise Exception,'qu must be a tuple: (Q,U)'
if xyout=='':
xyout=xytab
if xyout!=xytab:
os.system('cp -r '+xytab+' '+xyout)
QUexp=complex(qu[0],qu[1])
print 'Expected QU = ',qu # , ' (',pl.angle(QUexp)*180/pi,')'
mytb.open(xyout,nomodify=False)
QU=mytb.getkeyword('QU')['QU']
P=pl.sqrt(QU[0,:]**2+QU[1,:]**2)
nspw=P.shape[0]
for ispw in range(nspw):
st=mytb.query('SPECTRAL_WINDOW_ID=='+str(ispw))
if (st.nrows()>0):
q=QU[0,ispw]
u=QU[1,ispw]
qufound=complex(q,u)
c=st.getcol('CPARAM')
fl=st.getcol('FLAG')
xyph0=pl.angle(pl.mean(c[0,:,:][pl.logical_not(fl[0,:,:])]),True)
print 'Spw = '+str(ispw)+': Found QU = '+str(QU[:,ispw]) # +' ('+str(pl.angle(qufound)*180/pi)+')'
#if ( (abs(q)>0.0 and abs(qu[0])>0.0 and (q/qu[0])<0.0) or
# (abs(u)>0.0 and abs(qu[1])>0.0 and (u/qu[1])<0.0) ):
if ( pl.absolute(pl.angle(qufound/QUexp)*180/pi)>90.0 ):
c[0,:,:]*=-1.0
xyph1=pl.angle(pl.mean(c[0,:,:][pl.logical_not(fl[0,:,:])]),True)
st.putcol('CPARAM',c)
QU[:,ispw]*=-1
print ' ...CONVERTING X-Y phase from '+str(xyph0)+' to '+str(xyph1)+' deg'
else:
print ' ...KEEPING X-Y phase '+str(xyph0)+' deg'
st.close()
QUr={}
QUr['QU']=QU
mytb.putkeyword('QU',QUr)
mytb.close()
QUm=pl.mean(QU[:,P>0],1)
QUe=pl.std(QU[:,P>0],1)
Pm=pl.sqrt(QUm[0]**2+QUm[1]**2)
Xm=0.5*atan2(QUm[1],QUm[0])*180/pi
print 'Ambiguity resolved (spw mean): Q=',QUm[0],'U=',QUm[1],'(rms=',QUe[0],QUe[1],')','P=',Pm,'X=',Xm
stokes=[1.0,QUm[0],QUm[1],0.0]
print 'Returning the following Stokes vector: '+str(stokes)
return stokes
def Av_d(myfile,maxstar=None):
"""run red-clump fitting on the photometry in file, being a 2mass table in a particular
direction, either FITS or ascii"""
if myfile[-4:]=="fits" or myfile[-3:]=='fit' or myfile[-3:]=="FTS":
fred = pyfits.open(myfile)
pylab.figure(1)
pylab.clf()
table = fred[1].data
fred.close()
J = table.field("Jmag")
K = table.field("Kmag")
flags = table.field("Qflg")
r = table.field("_r")
if maxstar:
print "Max radius: %f arcmin"%r[maxstar]
else: print "Max radius: %f arcmin"%max(r)
else: #assume ascii file, with columns id,ra,dec,j,jerr,h,herr,k,kerr,flag...
fred = open(myfile)
mylines = fred.readlines()
J=[]
K=[]
flags=[]
for aline in mylines:
words = aline.split()
if len(words)<10: continue
J.append(float(words[3]))
K.append(float(words[7]))
flags.append(words[9])
J=pylab.array(J)
K=pylab.array(K)
if maxstar:
J = J[:maxstar]
K = K[:maxstar]
flags=flags[:maxstar]
fred.close()
pylab.figure(1)
pylab.clf()
pylab.plot(J-K,K,'k.')
pylab.xlabel("$J-K$")
pylab.ylabel("$K$")
first = eval(raw_input('Slice star values (python syntax): '))
last = eval(raw_input('Slice end values (python syntax): '))
jk,k,sig,nstar = run_clump(J,K,flags,first,last)
pylab.figure(1)
sam = pylab.errorbar(jk,k,yerr=(first-last)/2,xerr=sig/pylab.sqrt(nstar),capsize=0)
pylab.setp(sam[0],marker='d',mec='w',mfc='w',markersize=5,ls='None')
pylab.setp(sam[1],c='w',lw=2)
sam = pylab.errorbar(jk,k,yerr=(first-last)/2,xerr=sig/pylab.sqrt(nstar),capsize=0)
pylab.setp(sam[0],marker='d',mec='c',mfc='c',markersize=4,ls='None')
pylab.setp(sam[1],c='c',lw=1)
pylab.axis([0,2.5,15,5])
av,d,err = convert(jk,k,sig,nstar)
pylab.figure(2)
pylab.clf()
pylab.errorbar(d,av,err)
return jk,k,sig,nstar
def plot_regression(x,y,smoothing=.3):
fit=sm.nonparametric.lowess(y,x,frac=smoothing)
df=(fit[:,1]-y)**2
fit_var=sm.nonparametric.lowess(df,x,frac=smoothing)
isheld = pl.ishold()
pl.hold(1)
pl.plot(fit[:,0],fit[:,1])
pl.fill_between(fit_var[:,0],fit[:,1]-1*pl.sqrt(fit_var[:,1]),fit[:,1]+1*pl.sqrt(fit_var[:,1]),color=((0,0,.99,.2),))
pl.plot(x,y,'.')
pl.hold(isheld)
def calculate(self) :
print "Intensity:Intensity2D:calcaulate"
self.project()
self.sum = pl.sum(self.xproj)
self.xmean = pl.sum(self.xproj*self.x)/pl.sum(self.xproj)
self.ymean = pl.sum(self.yproj*self.y)/pl.sum(self.yproj)
self.xrms = pl.sqrt(pl.sum(self.xproj*self.x**2)/self.sum)
self.yrms = pl.sqrt(pl.sum(self.yproj*self.y**2)/self.sum)
print "Intensity:Intensity2D:calculate ",self.xmean,self.ymean,self.xrms,self.yrms
def random_euler_angles():
r1,r2,r3 = pylab.random(3)
q1 = pylab.sqrt(1.0-r1)*pylab.sin(2.0*pylab.pi*r2)
q2 = pylab.sqrt(1.0-r1)*pylab.cos(2.0*pylab.pi*r2)
q3 = pylab.sqrt(r1)*pylab.sin(2.0*pylab.pi*r3)
q4 = pylab.sqrt(r1)*pylab.cos(2.0*pylab.pi*r3)
phi = math.atan2(2.0*(q1*q2+q3*q4), 1.0-2.0*(q2**2+q3**2))
theta = math.asin(2.0*(q1*q3-q4*q2))
psi = math.atan2(2.0*(q1*q4+q2*q3), 1.0-2.0*(q3**2+q4**2))
return [phi,theta,psi]
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 calculate_boxplot_stats ( x, **kwargs ):
whis = kwargs.setdefault ( 'whis', 1.5 )
bootstrap = kwargs.setdefault ( 'bootstrap', None )
# Get median and quartiles
q1,med,q3 = pl.prctile (x, [25,50,75] )
# Get high extreme
iq = q3-q1
hi_val = q3+whis*iq
wisk_hi = pl.compress ( x<=hi_val, x )
if len(wisk_hi)==0:
wisk_hi = q3
else:
wisk_hi = max(wisk_hi)
# Get low extreme
lo_val = q1-whis*iq
wisk_lo = pl.compress ( x>=lo_val, x )
if len(wisk_lo)==0:
wisk_lo = q3
else:
wisk_lo = min(wisk_lo)
# Get fliers
flier_hi = pl.compress ( x>wisk_hi, x )
flier_lo = pl.compress ( x<wisk_lo, x )
if bootstrap is not None:
# Do a bootstrap estimate of notch locations
def bootstrapMedian ( data, N=5000 ):
# determine 95% confidence intervals of the median
M = len(data)
percentile = [2.5,97.5]
estimate = pl.zeros(N)
for n in xrange (N):
bsIndex = pl.randint ( 0, M, M )
bsData = data[bsIndex]
estimate[n] = pl.prctile ( bsData, 50 )
CI = pl.prctile ( estimate, percentile )
return CI
CI = bootstrapMedian ( x, N=bootstrap )
notch_max = CI[1]
notch_min = CI[0]
else:
# Estimate notch locations using Gaussian-based asymptotic
# approximation
#
# For discussion: McGill, R., Tukey, J.W., and
# Larsen, W.A. (1978) "Variations of Boxplots", The
# American Statistitian, 32:12-16
notch_max = med + 1.57*iq/pl.sqrt(len(x))
notch_min = med - 1.57*iq/pl.sqrt(len(x))
return {'main':(wisk_lo,q1,med,q3,wisk_hi),
'fliers':(flier_lo,flier_hi),
'notch':(notch_min,notch_max)}
def transform_vector(self,uin,vin,lons,lats,nx,ny,returnxy=False,preserve_magnitude=True):
"""
transform a vector field (uin,vin) from a lat/lon grid with longitudes
lons and latitudes lats to a (ny,nx) native map projection grid.
The input vector field is defined in spherical coordinates (it
has eastward and northward components) while the output
vector field is defined in map projection coordinates (relative
to x and y).
if returnxy=True, the x and y values of the native map projection grid
are also returned (default False).
if preserve_magnitude=True (default), the vector magnitude is preserved
(so that length of vectors represents magnitude of vector relative to
spherical coordinate system, not map projection coordinates).
vectors on a lat/lon grid must be transformed to map projection coordinates
before they be plotted on the map (with the quiver class method).
"""
lonsout, latsout, x, y = self.makegrid(nx,ny,returnxy=True)
# interpolate to map projection coordinates.
uin = interp(uin,lons,lats,lonsout,latsout)
vin = interp(vin,lons,lats,lonsout,latsout)
if preserve_magnitude:
# compute original magnitude.
mag = pylab.sqrt(uin**2+vin**2)
rad2dg = 180./math.pi
tiny = 1.e-5
delta = 0.1
coslats = pylab.cos(latsout/rad2dg)
# use dx/dlongitude, dx/dlatitude, dy/dlongitude and dy/dlatitude
# to transform vector to map projection coordinates.
# dlongitude is delta degrees at equator, dlatitude is delta degrees.
xn,yn = self(lonsout,pylab.where(latsout+delta<90.,latsout+delta,latsout))
# at poles, derivs w/respect to longitude will be zero.
lonse = pylab.where(coslats>tiny,lonsout+(delta/coslats),lonsout)
xe,ye = self(lonse,latsout)
uout = uin*(xe-x)*(coslats/delta) + vin*(xn-x)/delta
vout = uin*(ye-y)*(coslats/delta) + vin*(yn-y)/delta
# make sure uout, vout not too small (quiver will raise
# an exception when trying to rescale vectors).
uout = pylab.where(pylab.fabs(uout)<tiny,tiny,uout)
vout = pylab.where(pylab.fabs(vout)<tiny,tiny,vout)
# fix units.
if self.projection != 'cyl':
uout = uout*rad2dg/self.rsphere
vout = vout*rad2dg/self.rsphere
# rescale magnitude.
if preserve_magnitude:
magout = pylab.sqrt(uout**2+vout**2)
uout = uout*mag/magout
vout = vout*mag/magout
if returnxy:
return uout,vout,x,y
else:
return uout,vout
def calcunc(self,tdDatas):
#not used anymore, older version, should we remove it???
#tdDatas is a np array of tdData measurements
if tdDatas.shape[0]==1:
repeatability=py.zeros((len(tdDatas[0,:,0]),2))
else:
repeatability=py.std(py.asarray(tdDatas[:,:,1:3]),axis=0, ddof = 1)/py.sqrt(self.numberOfDataSets)
#this line is wrong
elnNoise=tdDatas[0,:,3:]
uncarray = py.sqrt(repeatability**2 + elnNoise**2)
return uncarray
def __init__( self, t, x, y, A=[1., 0.85], a=[0.25, 0.85] ):
'''
Initializing generalized thalamo-cortical loop. Full
functionality is only obtained in the subclasses, like DOG,
full_eDOG, etc.
Parameters
----------
t : array
1D Time vector
x : np.array
1D vector for x-axis sampling points
y : np.array
1D vector for y-axis sampling points
Keyword arguments
-----------------
A : sequence (default A = [1., 0.85])
Amplitudes for DOG receptive field for center and surround,
respectively
a : sequence (default a = [0.25, 0.85])
Width parameter for DOG receptive field for center and surround,
respectively
Usage
-----
Look at subclasses for example usage
'''
# Set parameteres as attributes
self.name = 'pyDOG Toolbox'
self.t = t
self.A = A
self.a = a
self.x = x
self.y = y
# Find sampling rates and sampling freqs and
self.nu_xs = 1./(x[1]-x[0])
self.nu_ys = 1./(y[1]-y[0])
self.fs = 1./(t[1]-t[0])
self.f = fft.fftfreq(pl.asarray(t).size, t[1]-t[0])
# fftshift spatial frequency,
self.nu_x = fft.fftfreq(pl.asarray(x).size, x[1]-x[0])
self.nu_y = fft.fftfreq(pl.asarray(y).size, y[1]-y[0])
# Make meshgrids, may come in handy
self._xx, self._yy = pl.meshgrid(self.x, self.y)
self._nu_xx, self._nu_yy = pl.meshgrid(self.nu_x, self.nu_y)
# r is needed for all circular rfs
self.r = pl.sqrt(self._xx**2 + self._yy**2)
self.k = 2 * pl.pi * pl.sqrt(self._nu_xx**2 + self._nu_yy**2)
def cartesian2polar(xyz):
"""cartesian2polar(x, y, z)
converts coordinate from xyz to r\theta\phi"""
x, y, z = xyz
## if z == 0:
## raise exceptions.ValueError("cartesian " + str(xyz) + " z must be nonzero.")
r = pylab.sqrt(sum(map(lambda x: x**2, [x, y, z])))
theta = pylab.arccos(z/r)
phi = pylab.arccos(x / pylab.sqrt(sum(map(lambda x: x**2, [x, y]))))
if y < 0: phi *= -1
return (r, theta, phi)
def Main():
options, _ = MakeOpts().parse_args(sys.argv)
assert options.species_filename
assert options.first_col and options.second_col
print 'Reading species list from', options.species_filename
filter_cols, filter_vals = [], []
if options.filter_cols:
assert options.filter_vals
filter_cols = map(str.strip, options.filter_cols.split(','))
filter_vals = map(str.strip, options.filter_vals.split(','))
# Read and filter species data
r = csv.DictReader(open(options.species_filename))
first_col, second_col = options.first_col, options.second_col
pairmap = {}
for row in r:
apply_filter = lambda x, y: x in row and row[x] == y
or_reduce = lambda x, y: x or y
passed_filter = reduce(or_reduce,
map(apply_filter, filter_cols, filter_vals),
True)
if not passed_filter:
continue
a, b = row[first_col].strip(), row[second_col].strip()
if not a or not b:
continue
key = (a, b)
pairmap.setdefault(key, []).append(row)
#for key, row_list in pairmap.iteritems():
# if len(row_list) < 5:
# print key, row_list
# Find cross-product of column values (all pairs).
all_a = list(set([x[0] for x in pairmap.keys()]))
all_b = list(set([x[1] for x in pairmap.keys()]))
a_to_num = dict((v, i) for i, v in enumerate(all_a))
b_to_num = dict((v, i) for i, v in enumerate(all_b))
all_possible_pairs = list(itertools.product(all_a, all_b))
third_col = options.third_col or 'fake key'
get_col = lambda x: x.get(third_col, None)
col_vals = dict((k, map(get_col, v)) for k, v in pairmap.iteritems())
counts = {}
totals = []
all_vals = set()
for k, v in col_vals.iteritems():
counter = Counter(v)
all_vals.update(counter.keys())
counts[k] = counter
totals.append(sum(counter.values()))
x_vals = []
y_vals = []
count_array = []
z_vals = []
max_val = max(totals)
for pair in all_possible_pairs:
a, b = pair
x_vals.append(a_to_num[a])
y_vals.append(b_to_num[b])
z_vals.append(sum(counts.get(pair, {}).values()))
count_array.append(counts.get(pair, {}))
# Plot circle scatter.
axes = pylab.axes()
axes.grid(color='g', linestyle='--', linewidth=1)
if options.third_col:
colormap = ColorMap(all_vals)
PieScatter(axes, x_vals, y_vals, count_array, max_val, colormap)
handles, labels = axes.get_legend_handles_labels()
mapped_labels = dict(zip(labels, handles))
labels = sorted(mapped_labels.keys())
handles = [mapped_labels[k] for k in labels]
pylab.legend(handles, labels)
else:
scaled_z_vals = pylab.array(map(float, z_vals))
max_z = max(scaled_z_vals)
scaled_z_vals /= (4.0 * max_z)
scaled_z_vals = pylab.sqrt(scaled_z_vals)
CircleScatter(axes, x_vals, y_vals, scaled_z_vals)
for x, y, z in zip(x_vals, y_vals, z_vals):
pylab.text(x + 0.1, y + 0.1, str(z))
# Labels, titles and ticks.
pylab.title('%s vs. %s' % (options.first_col, options.second_col))
pylab.xlabel(options.first_col)
pylab.ylabel(options.second_col)
pylab.figtext(0.70, 0.02, '%d examples total.' % sum(totals))
size_8 = FontProperties(size=8)
a_labels = [a or "None given" for a in all_a]
b_labels = [b or "None given" for b in all_b]
pylab.xticks(range(0, len(a_labels)), a_labels, fontproperties=size_8)
pylab.yticks(range(0, len(b_labels)), b_labels, fontproperties=size_8)
# Scale and show.
pylab.axis('scaled')
pylab.axis([-1, len(all_a), -1, len(all_b)])
pylab.show()
import pylab as p
x = p.linspace(10, 100, 100000)
n = len(x)
#for i in range(10,15):
c = p.array([10] * n)
y = c + 1 / (p.sqrt(x))
p.figure("Series")
p.plot(x, y)
p.title("DC Motor analysis")
p.xlabel("Torque")
p.ylabel("Speed")
p.show()
p.figure("Shunt")
p.plot(x, y)
p.title("DC Motor analysis")
p.xlabel("Torque")
p.ylabel("Speed")
p.show()
pylab.errorbar(t, x, dx, dt, "o", color="black") #aggiungere eventuali errori
def fit_function(t, tau, a, omega, phi, k):
return a*(math.e)**(-t/tau)*pylab.sin(omega*t+phi)+k
init = numpy.array([15, 450, 0.4, -3.14/2, 400]) #variare i parametri iniziali per ottenere diverse omega.
popt, pcov = curve_fit(fit_function, t, x, init, error, "true") #aggiungere l'errore
tau, a, omega, phi, k = popt
#dtau = 0
#da = 0
#domega = 0
#dphi = 0
#dk
dtau, da, domega, dphi, dk = pylab.sqrt(((pcov.diagonal())))
print("Parametri del fit:")
print("tau = ", tau, "a = ", a, "omega = ", 1000*omega, "phi = ", phi, "k = ", k)
print("dtau = ", dtau, "da = ", da, "domega = ", 1000*domega, "dphi = ", dphi, "dk = ", dk)
print(dtau, da, 1000*domega, dphi, dk)
div = 100000
bucket = numpy.array([0.0 for i in range(div)])
retta = numpy.array([0.0 for i in range(div)])
inc = (t.max())/div
for i in range(len(bucket)):
bucket[i]=float(i)*inc
retta[i] = fit_function(bucket[i], tau, a, omega, phi, k)
pylab.plot(bucket, retta, color = "black")
genome_size_std = p.zeros(tot_gain_at_repr.shape[0])
ASLD_means = p.zeros(tot_gain_at_repr.shape[0])
for i in xrange(0, tot_gain_at_repr.shape[0], 1):
ASLD_means[i] = p.sum(ASLD[i, :] * ASLD_hist_ranges) / p.sum(ASLD[i, :])
# ASLD[i, :] = ASLD[i, :] / ASLD[i, :].sum()
tot_gain_means[i] = p.sum(tot_gain_at_repr[i, :] * uptake_hist_ranges) \
/ p.sum(tot_gain_at_repr[i, :])
intake_means[i] = p.sum(intake_at_repr[i, :] * uptake_hist_ranges) \
/ p.sum(intake_at_repr[i, :])
genome_size_means[i] = p.sum(genome_size[i, :] * genome_size_bins) \
/ p.sum(genome_size[i, :])
for j in xrange(0, genome_size[i, :].shape[0], 1):
genome_size_std[i] += genome_size[i, j] \
* (genome_size_bins[j] - genome_size_means[i])**2
genome_size_std[i] = p.sqrt(genome_size_std[i] / p.sum(genome_size[i, :]))
Summ_ASLD = p.zeros(ASLD.shape[1])
ASLD_to_hist_mean = p.zeros(ASLD.shape[1])
ASLD_to_hist_std = p.zeros(ASLD.shape[1])
for j in xrange(0, ASLD.shape[1], 1):
ASLD_to_hist_mean[j] = ASLD[:, j].mean()
ASLD_to_hist_std[j] = ASLD[:, j].std()
Summ_ASLD[j] = p.sum(ASLD[:, j])
#Summ_ASLD = Summ_ASLD[~p.isnan(Summ_ASLD).any(0)]
#The_summ_ASLD = Summ_ASLD.mean()
#ASLD_to_hist_mean = ASLD_to_hist_mean / Summ_ASLD
#ASLD_to_hist_std = ASLD_to_hist_std / Summ_ASLD
tot_gain_means = tot_gain_means[~p.isnan(tot_gain_means).any(0)]
def extract(self):
Features.extract(self)
self.X = P.sqrt((P.diff(self.X)**2).sum(0))/self.X.shape[0]
