def qnwcheb1(n, a, b):
""" Univariate Gauss-Chebyshev quadrature nodes and weights
Parameters
-----------
n : int
number of nodes
a : float
left endpoint
b : float
right endpoint
Returns
---------
x : array, shape (n,)
nodes
x : array, shape (n,)
weights
Notes
---------
Port of the qnwcheb1 function in the compecon matlab toolbox.
"""
x = ((b + a) / 2 - (b - a) / 2
* sp.cos(sp.pi / n * sp.arange(0.5, n + 0.5, 1)))
w2 = sp.r_[1, -2. / (sp.r_[1:(n - 1):2] * sp.r_[3:(n + 1):2])]
w1 = (sp.cos(sp.pi / n * sp.mat((sp.r_[0:n] + 0.5)).T *
sp.mat((sp.r_[0:n:2]))).A)
w0 = (b - a) / n
w = w0 * sp.dot(w1, w2)
return x, w
def f(self, x):
B1 = 0.5 * sin(x[0]) - 2*cos(x[0]) + sin(x[1]) -1.5*cos(x[1])
B2 = 1.5 * sin(x[0]) - cos(x[0]) + 2*sin(x[1]) -0.5*cos(x[1])
f1 = 1 + (self._A1-B1)**2 + (self._A2-B2)**2
f2 = (x[0]+3)**2 + (x[1]+1)**2
return -array([f1, f2])
def xyzfield(gcoefs, hcoefs, phi, theta, rparam=1.0, order=13):
# no usar esta función, es peor en rendimiento
x, y, z = 0, 0, 0
legendre, dlegendre = scipy.special.lpmn(order + 1, order + 1, scipy.cos(theta))
for l in range(1, order + 1):
for m in range(0, l + 1):
deltax = (
rparam ** (l + 2)
* (gcoefs[m, l] * scipy.cos(m * phi) + hcoefs[m, l] * scipy.sin(m * phi))
* dlegendre[m, l]
* (-scipy.sin(theta))
)
deltay = (
rparam ** (l + 2)
* (gcoefs[m, l] * scipy.sin(m * phi) - hcoefs[m, l] * scipy.cos(m * phi))
* m
* legendre[m, l]
/ (scipy.sin(theta))
)
deltaz = (
rparam ** (l + 2)
* (l + 1)
* (gcoefs[m, l] * scipy.cos(m * phi) + hcoefs[m, l] * scipy.sin(m * phi))
* legendre[m, l]
)
x += deltax
y += deltay
z += deltaz
return (x, y, z)
def GetReward(self, x):
# r: the returned reward.
# f: true if the car reached the goal, otherwise f is false
y_acrobot = [0, 0, 0]
theta1 = x[0]
theta2 = x[1]
y_acrobot[1] = y_acrobot[0] - cos(theta1)
y_acrobot[2] = y_acrobot[1] - cos(theta2)
#print y_acrobot
#goal
goal = y_acrobot[0] + self.target
if self.easy_rewards:
r = y_acrobot[2]
else:
#r = -0.01
r = 0
f = 0
if y_acrobot[2] >= goal:
if self.easy_rewards:
r = 10 * y_acrobot[2]
else:
r = 1
f = 1
if self.steps >= self.maxSteps:
f = 5
#r = -1
return r, f
def test_time_integration():
dt = 0.01
tmax = 1
def check_time_integration(res, y0, exact):
ts, ys = time_integrate(res, y0, dt, tmax)
exacts = [exact(t) for t in ts]
print(ts, ys, exacts)
utils.assert_list_almost_equal(ys, exacts, 1e-3)
tests = [
(lambda t, y, dy: y - dy, 1.0, lambda t: array(exp(t))),
(lambda t, y, dy: y + dy, 1.0, lambda t: array(exp(-t))),
(
lambda t, y, dy: array([-0.1 * sin(t), y[1]]) - dy,
array([0.1 * cos(0.0), exp(0.0)]),
lambda t: array([0.1 * cos(t), exp(t)]),
),
]
for r, y0, exact in tests:
yield check_time_integration, r, y0, exact
def radec_to_lb_single(ra,dec,T,degree=False):
"""
NAME:
radec_to_lb_single
PURPOSE:
transform from equatorial coordinates to Galactic coordinates for a single pair of ra,dec
INPUT:
ra - right ascension
dec - declination
T - epoch dependent transformation matrix (dictionary)
degree - (Bool) if True, ra and dec are given in degree and l and b will be as well
OUTPUT:
l,b
HISTORY:
2009-11-12 - Written - Bovy (NYU)
"""
T=T['T']
if degree:
thisra= ra/180.*sc.pi
thisdec= dec/180.*sc.pi
else:
thisra= ra
thisdec= dec
XYZ=sc.array([sc.cos(thisdec)*sc.cos(thisra),sc.cos(thisdec)*sc.sin(thisra),sc.sin(thisdec)])
galXYZ= sc.dot(T,XYZ)
b= m.asin(galXYZ[2])
l= m.atan(galXYZ[1]/galXYZ[0])
if galXYZ[0]/sc.cos(b) < 0.:
l+= sc.pi
if l < 0.:
l+= 2.*sc.pi
if degree:
return (l/sc.pi*180.,b/sc.pi*180.)
else:
return (l,b)
def evaluateSphericalVariation (phi,theta,cntPhi,cntTheta):
global conf,cons
success = False
alpha0 =sp.zeros([dim['alpha']],complex)
alpha0[conf['id0']]=sp.cos(phi)*sp.sin(theta)+0j
alpha0[conf['id1']]=sp.sin(phi)*sp.sin(theta)+0j
alpha0[conf['id2']]=sp.cos(theta)+0j
# if (sp.absolute(alpha0[conf['id0']]) <= 1e-10):
# alpha0[conf['id0']]=0.0+0j
# if (sp.absolute(alpha0[conf['id1']]) <= 1e-10):
# alpha0[conf['id1']]=0.0+0j
# if (sp.absolute(alpha0[conf['id2']]) <= 1e-10):
# alpha0[conf['id2']]=0.0+0j
#
# normalize coefficients for alpha -> defines net-power
alpha0[:]=alpha0[:]/sp.linalg.norm(alpha0[:])*cons['alpha_norm']
__,res = MemoryPulseFunctional.evaluateFunctional(alpha0,1.0+0j)
myRes = sp.zeros([conf['entries']+3])
myRes[0] = alpha0[conf['id0']].real
myRes[1] = alpha0[conf['id1']].real
myRes[2] = alpha0[conf['id2']].real
myRes[3:]= res
print "### spherical map: phi/pi={0:5.3f}, theta/pi={1:5.3f}, fun={2:f}".format(phi/sp.pi,theta/sp.pi,myRes[conf['funval']])
myRes[conf['funval']] = min(conf['cutoff'],res[conf['funval']])
return myRes,cntPhi,cntTheta
def lat_lon_2_vertex(lat,lon): """ A routine to return the location of a detector's vertex in 3D Cartesean Coordinates given the latitude and longitude of the detector. This routine approximates teh Earth as a sphere. """ return (metric.R_earth*cos(lon)*cos(lat), metric.R_earth*sin(lon)*cos(lat), metric.R_earth*sin(lat))
def form_point_set(self, histo, point_set):
(slices, numbins) = histo.shape
phases = numpy.arange(numbins)
phases = phases * (360. / numbins)
phases += phases[1] / 2.
phi_step = phases[0]
for time in xrange(slices):
z = float(time)
for bin in xrange(numbins):
r = histo[time,bin]
theta = phi_step * (bin+1)
theta *= (scipy.pi / 180.)
x = r*scipy.cos(theta)
y = r*scipy.sin(theta)
point_set.InsertNextPoint(x, y, z)
for bin in xrange(numbins):
curbin = bin
lastbin = bin-1
if lastbin < 0:
lastbin = numbins-1
r = (histo[time,bin] - histo[time,lastbin]) / 2.
theta = curbin * 360. / numbins
x = r*scipy.cos(theta)
y = r*scipy.sin(theta)
point_set.InsertNextPoint(x, y, z)
def binary_ephem(P, T, e, a, i, O_node, o_peri, t):
# Grados a radianes
d2rad = pi/180.
rad2d = 180./pi
i = i*d2rad
O_node = (O_node*d2rad)%(2*pi)
o_peri = (o_peri*d2rad)%(2*pi)
# Anomalia media
M = ((2.0*pi)/P)*(t - T) # radianes
if M >2*pi: M = M - 2*pi
M=M%(2*pi)
# Anomalia excentrica (1ra aproximacion)
E0 = M + e*sin(M) + (e**2/M) * sin(2.0*M)
for itera in range(15):
M0 = E0 - e*sin(E0)
E0 = E0 + (M-M0)/(1-e*cos(E0))
true_anom = 2.0*arctan(sqrt((1+e)/(1-e))*tan(E0/2.0))
#radius = (a*(1-e**2))/(1+e*cos(true_anom))
radius = a*(1-e*cos(E0))
theta = arctan( tan(true_anom + o_peri)*cos(i) ) + O_node
rho = radius * (cos(true_anom + o_peri)/cos(theta - O_node))
# revuelve rho ("), theta (grad), Anomalia excentrica (grad), Anomalia verdadera (grad)
return rho, (theta*rad2d)%360. #, E0*rad2d, M*rad2d, true_anom*rad2d
def rotate(self, angle, mask=None):
"""Rotate the grids (arena centered)
Grids to be rotated can be optionally specified by bool/index array
*mask*, otherwise population is rotated. Specified *angle* can be a
scalar value to be applied to the population or a population- or
mask-sized array depending on whether *mask* is specified.
"""
rot2D = lambda psi: [[cos(psi), sin(psi)], [-sin(psi), cos(psi)]]
if mask is not None and type(mask) is np.ndarray:
if mask.dtype.kind == 'b':
mask = mask.nonzero()[0]
if type(angle) is np.ndarray and angle.size == mask.size:
for i,ix in enumerate(mask):
self._phi[ix] = np.dot(self._phi[ix], rot2D(angle[i]))
elif type(angle) in (int, float, np.float64):
angle = float(angle)
self._phi[mask] = np.dot(self._phi[mask], rot2D(angle))
else:
raise TypeError, 'angle must be mask-sized array or float'
self._psi[mask] = np.fmod(self._psi[mask]+angle, 2*pi)
elif mask is None:
if type(angle) is np.ndarray and angle.size == self.num_maps:
for i in xrange(self.num_maps):
self._phi[i] = np.dot(self._phi[i], rot2D(angle[i]))
elif type(angle) in (int, float, np.float64):
angle = float(angle)
self._phi = np.dot(self._phi, rot2D(angle))
else:
raise TypeError, 'angle must be num_maps array or float'
self._psi = np.fmod(self._psi+angle, 2*pi)
else:
raise TypeError, 'mask must be bool/index array'
def __init__(self,alphai,eparall,eperp,nrj):
"""
Incident wave above a surface.
Coordinates:
- z is perpendicular to the surface, >0 going UP (different from H Dosch's convention)
- x is the projection of the wavevector on the surface
- y is parallel to the surface
alphai: incident angle, with respect to the surface
eparallel: component of the electric field parallel to the incident plane (vertical plane)
eperp: component of the electric field perpendicular to the incident plane (along y)
nrj: values of the energy of the incident wave, in eV
alphai *or* nrj can be arrays, but not together
"""
self.alphai=alphai
self.eparall=eparall
self.eperp=eperp
self.ex=scipy.sin(alphai)*eparall
self.ey=eperp
self.ez=scipy.cos(alphai)*eparall
self.kx= 2*pi/W2E(nrj)*scipy.cos(alphai)
self.ky= 2*pi/W2E(nrj)*0
self.kz=-2*pi/W2E(nrj)*scipy.sin(alphai)
self.nrj=nrj
def ned2ecef(lat, lon, alt, n, e, d):
X0, Y0, Z0 = coord.geodetic2ecef(lat, lon, alt)
lat, lon = radians(lat), radians(lon)
pitch = math.pi/2 + lat
yaw = -lon
my = mat('[%f %f %f; %f %f %f; %f %f %f]' %
(cos(pitch), 0, -sin(pitch),
0,1,0,
sin(pitch), 0, cos(pitch)))
mz = mat('[%f %f %f; %f %f %f; %f %f %f]' %
(cos(yaw), sin(yaw),0,
-sin(yaw),cos(yaw),0,
0,0,1))
mr = mat('[%f %f %f; %f %f %f; %f %f %f]' %
(-cos(lon)*sin(lat), -sin(lon), -cos(lat) * cos(lon),
-sin(lat)*sin(lon), cos(lon), -sin(lon)*cos(lat),
cos(lat), 0, -sin(lat)))
geo = mat('[%f; %f; %f]' % (X0, Y0, Z0))
ned = mat('[%f; %f; %f]' % (n, e, d))
res = mr*ned + geo
return res[0], res[1], res[2]
def get_bl(self,ra=None,dec=None):
"""
http://scienceworld.wolfram.com/astronomy/GalacticCoordinates.html
"""
if ra==None: ra=self.get_column("RA")
if dec==None: dec=self.get_column("DEC")
if type(ra)==float:
ral=scipy.zeros(1)
ral[0]=ra
ra=ral
if type(dec)==float:
decl=scipy.zeros(1)
decl[0]=dec
dec=decl
c62=math.cos(62.6*D2R)
s62=math.sin(62.6*D2R)
b=scipy.sin(dec*D2R)*c62
b-=scipy.cos(dec*D2R)*scipy.sin((ra-282.25)*D2R)*s62
b=scipy.arcsin(b)*R2D
cosb=scipy.cos(b*D2R)
#l minus 33 degrees
lm33=(scipy.cos(dec*D2R)/cosb)*scipy.cos((ra-282.25))
l=scipy.arccos(lm33)*R2D+33.0
return b,l
def __init__(self,id,matName,orientation,source=0.0):
self.id = id
self.matName = matName
self.orientation = orientation
self.source = source
self.T = array([[cos(orientation),-sin(orientation)],
[sin(orientation), cos(orientation)]])
def setUp(self):
# Make a positive definite noise matrix, clean map, and dirty_map.
self.nra = 10
self.ndec = 5
self.nf = 20
self.shape = (self.nf, self.nra, self.ndec)
self.size = self.nra * self.ndec * self.nf
# Clean map.
clean_map = sp.empty(self.shape, dtype=float)
clean_map = al.make_vect(clean_map, axis_names=('freq', 'ra', 'dec'))
clean_map[...] = sp.sin(sp.arange(self.nf))[:,None,None]
clean_map *= sp.cos(sp.arange(self.nra))[:,None]
clean_map *= sp.cos(sp.arange(self.ndec))
# Noise inverse matrix.
noise_inv = sp.empty(self.shape * 2, dtype=float)
noise_inv = al.make_mat(noise_inv, axis_names=('freq', 'ra', 'dec')*2,
row_axes=(0, 1, 2), col_axes=(3, 4, 5))
rand_mat = rand.randn(*((self.size,) * 2))
information_factor = 1.e6 # K**-2
rand_mat = sp.dot(rand_mat, rand_mat.transpose()) * information_factor
noise_inv.flat[...] = rand_mat.flat
# Dirty map.
dirty_map = al.partial_dot(noise_inv, clean_map)
# Store in self.
self.clean_map = clean_map
self.noise_inv = noise_inv
self.dirty_map = dirty_map
def sky_ra_dec(self, ra, dec):
ra_dec_shape = (ra * dec).shape
sl = (slice(None),) + (None,) * (ra * dec).ndim
time_stream = sp.zeros((self.nf,) + ra_dec_shape)
time_stream += sp.sin(ra*0.9 + 3.0)*sp.cos(dec*1.3 + 2.0) # The sky map.
time_stream *= sp.cos(sp.arange(self.nf, dtype=float) + 5.0)[sl] + 1.2
return time_stream
def rect_to_cyl_vec(vx,vy,vz,X,Y,Z,cyl=False):
"""
NAME:
rect_to_cyl_vec
PURPOSE:
transform vectors from rectangular to cylindrical coordinates vectors
INPUT:
vx -
vy -
vz -
X - X
Y - Y
Z - Z
cyl - if True, X,Y,Z are already cylindrical
OUTPUT:
vR,vT,vz
HISTORY:
2010-09-24 - Written - Bovy (NYU)
"""
if not cyl:
R,phi,Z= rect_to_cyl(X,Y,Z)
else:
phi= Y
vr=+vx*sc.cos(phi)+vy*sc.sin(phi)
vt= -vx*sc.sin(phi)+vy*sc.cos(phi)
return (vr,vt,vz)
def radec_to_lb(ra,dec,degree=False,epoch=2000.0):
"""
NAME:
radec_to_lb
PURPOSE:
transform from equatorial coordinates to Galactic coordinates
INPUT:
ra - right ascension
dec - declination
degree - (Bool) if True, ra and dec are given in degree and l and b will be as well
epoch - epoch of ra,dec (right now only 2000.0 and 1950.0 are supported)
OUTPUT:
l,b
For vector inputs [:,2]
HISTORY:
2009-11-12 - Written - Bovy (NYU)
2014-06-14 - Re-written w/ numpy functions for speed and w/ decorators for beauty - Bovy (IAS)
"""
import math as m
import numpy as nu
import scipy as sc
#First calculate the transformation matrix T
theta,dec_ngp,ra_ngp= get_epoch_angles(epoch)
T= sc.dot(sc.array([[sc.cos(theta),sc.sin(theta),0.],[sc.sin(theta),-sc.cos(theta),0.],[0.,0.,1.]]),sc.dot(sc.array([[-sc.sin(dec_ngp),0.,sc.cos(dec_ngp)],[0.,1.,0.],[sc.cos(dec_ngp),0.,sc.sin(dec_ngp)]]),sc.array([[sc.cos(ra_ngp),sc.sin(ra_ngp),0.],[-sc.sin(ra_ngp),sc.cos(ra_ngp),0.],[0.,0.,1.]])))
#Whether to use degrees and scalar input is handled by decorators
XYZ= nu.array([nu.cos(dec)*nu.cos(ra),
nu.cos(dec)*nu.sin(ra),
nu.sin(dec)])
galXYZ= nu.dot(T,XYZ)
b= nu.arcsin(galXYZ[2])
l= nu.arctan2(galXYZ[1]/sc.cos(b),galXYZ[0]/sc.cos(b))
l[l<0.]+= 2.*nu.pi
out= nu.array([l,b])
return out.T
def getObservation(self):
obs = array(impl.getObs())
if self.verbose:
print(('obs', obs))
obs.resize(self.outdim)
if self.extraObservations:
cartpos = obs[-1]
if self.markov:
angle1 = obs[1]
else:
angle1 = obs[0]
obs[-1 + self.extraRandoms] = 0.1 * cos(angle1) + cartpos
obs[-2 + self.extraRandoms] = 0.1 * sin(angle1) + cartpos
if self.numPoles == 2:
if self.markov:
angle2 = obs[3]
else:
angle2 = obs[1]
obs[-3 + self.extraRandoms] = 0.05 * cos(angle2) + cartpos
obs[-4 + self.extraRandoms] = 0.05 * sin(angle2) + cartpos
if self.extraRandoms > 0:
obs[-self.extraRandoms:] = randn(self.extraRandoms)
if self.verbose:
print(('obs', obs))
return obs
def _genBFEdgeZero(plasma, zeros, rcent, zcent):
""" this will absolutely need to be rewritten"""
theta = scipy.linspace(-scipy.pi,scipy.pi,zeros)
cent = geometry.Point(geometry.Vecr([rcent,0,zcent]),plasma)
zerobeam = []
outline = []
for i in xrange(len(plasma.norm.s)-1):
outline += [geometry.Vecx([plasma.sagi.s[i],
0,
plasma.norm.s[i]])-cent]
for i in xrange(zeros):
temp2 = geometry.Vecr([scipy.cos(theta[i]),
0,
scipy.sin(theta[i])])
s = 0
for j in outline:
temp4 = j*temp2
if temp4 > s:
s = temp4
temp2.s = s
zerobeam += [Ray(geometry.Point(cent+temp2,
plasma),
geometry.Vecr([scipy.sin(theta[i]),
0,
-scipy.cos(theta[i])]))]
return zerobeam
def residuals(self, p,errors, f,freq_val):
theta = self.theta
# Isrc = 19.6*pow((750.0/freq_val[f]),0.495)*2
# Isrc = 19.6*pow((750.0/freq_val[f]),0.495)*(2.28315426-0.000484307905*freq_val[f]) # Added linear fit for Jansky to Kelvin conversion.
# Isrc = 19.74748409*pow((750.0/freq_val[f]),0.49899785)*(2.28315426-0.000484307905*freq_val[f]) # My fit solution for 3C286
Isrc = 25.15445092*pow((750.0/freq_val[f]),0.75578842)*(2.28315426-0.000484307905*freq_val[f]) # My fit solution for 3C48
# Isrc = 4.56303633*pow((750.0/freq_val[f]),0.59237327)*(2.28315426-0.000484307905*freq_val[f]) # My fit solution for 3C67
PAsrc = 33.0*sp.pi/180.0 # for 3C286, doesn't matter for unpolarized.
# Psrc = 0.07 #for 3C286
Psrc = 0 #for #3C48,3C67
Qsrc = Isrc*Psrc*sp.cos(2*PAsrc)
Usrc = Isrc*Psrc*sp.sin(2*PAsrc)
Vsrc = 0
XXsrc0 = Isrc-Qsrc
YYsrc0 = Isrc+Qsrc
# XXsrc = (0.5*(1+sp.cos(2*theta[i]))*XXsrc0-sp.sin(2*theta[i])*Usrc+0.5*(1-sp.cos(2*theta[i]))*YYsrc0)
# YYsrc = (0.5*(1-sp.cos(2*theta[i]))*XXsrc0+sp.sin(2*theta[i])*Usrc+0.5*(1+sp.cos(2*theta[i]))*YYsrc0)
source = sp.zeros(4*self.file_num)
for i in range(0,len(source),4):
source[i] = (0.5*(1+sp.cos(2*theta[i]))*XXsrc0-sp.sin(2*theta[i])*Usrc+0.5*(1-sp.cos(2*theta[i]))*YYsrc0)
source[i+1] = 0
source[i+2] = 0
source[i+3] = (0.5*(1-sp.cos(2*theta[i]))*XXsrc0+sp.sin(2*theta[i])*Usrc+0.5*(1+sp.cos(2*theta[i]))*YYsrc0)
err = (source-self.peval(p,f))/errors
return err
def f(self, x):
res = 0
for i in range(self.xdim):
Ai = sum(self.A[i] * sin(self.alphas) + self.B[i] * cos(self.alphas))
Bix = sum(self.A[i] * sin(x) + self.B[i] * cos(x))
res += (Ai - Bix) ** 2
return res
def InitJackArrays(self,freq,samples): """Initialize Jack Arrays""" self.iIa = sp.zeros(samples).astype(sp.float32) self.iQa = sp.zeros(samples).astype(sp.float32) self.oIa = sp.zeros(samples, dtype=sp.float32 ) self.oQa = sp.zeros(samples, dtype=sp.float32 ) ## 100 frames warmup sf = 0 ef = self.rtframes2sync samples = sp.pi + (2*sp.pi*freq*(self.dt * sp.r_[sf:ef])) self.oIa[sf:ef] = self.amp * sp.cos(samples) self.oQa[sf:ef] = self.amp * sp.sin(samples) # For IQ balancing #self.oIa[sf:ef] = sp.cos(samples) - (sp.sin(samples)*(1+self.oalpha)*sp.sin(self.ophi)) #self.oQa[sf:ef] = sp.sin(samples)*(1+self.oalpha)*sp.cos(self.ophi) ## 180 phase change sf = ef ef = ef + self.sync2fft + self.fftn + self.fft2end samples = (2*sp.pi*freq*(self.dt * sp.r_[sf:ef])) self.oIa[sf:ef] = self.amp * sp.cos(samples) self.oQa[sf:ef] = self.amp * sp.sin(samples)
def test_correlate(self) :
Data = self.blocks[0]
Data.calc_freq()
map = self.map
gain = 3.45
const = 2.14
# Set all data = gain*(cos(time_ind)).
Data.data[:,:,:,:] = gain*sp.cos(sp.arange(1,11)
[:,sp.newaxis,sp.newaxis,sp.newaxis])
# Explicitly set time mean to something known.
Data.data -= ma.mean(Data.data, 0)
Data.data += gain*const*Data.freq/800.0e6
# Now the Map.
map[:,:,:] = 0.0
# Set 10 pixels to match cos part of data.
map[:, range(10), range(10)] = (
sp.cos(sp.arange(1,11)[None, :]))
map[:, range(10), range(10)] -= ma.mean(
map[:, range(10), range(10)], 1)[:, None]
# Give Map a mean to test things out. Should really have no effect.
map[...] += 0.352*map.get_axis('freq')[:, None, None]/800.0e6
# Rig the pointing to point to those 10 pixels.
def rigged_pointing() :
Data.ra = map.get_axis('ra')[range(10)]
Data.dec = map.get_axis('dec')[range(10)]
Data.calc_pointing = rigged_pointing
solved_gains = smd.sub_map(Data, map, correlate=True)
# Now data should be just be gain*const*f, within machine precision.
Data.data /= gain*Data.freq/800.0e6
self.assertTrue(sp.allclose(Data.data[:,:,:,:], const))
self.assertTrue(sp.allclose(solved_gains, gain))
def cyl_to_rect_vec(vr,vt,vz,phi):
"""
NAME:
cyl_to_rect_vec
PURPOSE:
transform vectors from cylindrical to rectangular coordinate vectors
INPUT:
vr - radial velocity
vt - tangential velocity
vz - vertical velocity
phi - azimuth
OUTPUT:
vx,vy,vz
HISTORY:
2011-02-24 - Written - Bovy (NYU)
"""
vx= vr*sc.cos(phi)-vt*sc.sin(phi)
vy= vr*sc.sin(phi)+vt*sc.cos(phi)
return (vx,vy,vz)
def lla2ecef(lla: Sequence[float], cst: ConstantsFile, lla_as_degrees: bool=False) -> Tuple[float, float, float]:
"""
converts LLA (Latitude, Longitude, Altitude) coordinates
to ECEF (Earth-Centre, Earth-First) XYZ coordinates.
"""
lat, lon, alt = lla
if lla_as_degrees:
lat = radians(lat)
lon = radians(lon)
a = cst.semi_major_axis
b = cst.semi_minor_axis
# calc. ellipsoid flatness
f = (a - b) / a
# calc. eccentricity
e = sqrt(f * (2 - f))
# Calculate length of the normal to the ellipsoid
N = a / sqrt(1 - (e * sin(lat)) ** 2)
# Calculate ecef coordinates
x = (N + alt) * cos(lat) * cos(lon)
y = (N + alt) * cos(lat) * sin(lon)
z = (N * (1 - e ** 2) + alt) * sin(lat)
# Return the ecef coordinates
return x, y, z
def CalcXY2GPSParam_2p(x1,x2,g1,g2,K=[0,0]): # Kx = dLng/dx; Ky = dlat/dy; # In China: # Kx = (133.4-1.2*lat)*1e3 # Ky = (110.2+0.002*lat)*1e3 X1 = array(x1) Y1 = array(g1) X2 = array(x2) Y2 = array(g2) detX = X2-X1 detY = Y2-Y1 lat = Y1[1] if K[0] == 0: Kx = (133.4-1.2*lat)*1e3 Ky = (110.2+0.002*lat)*1e3 K = array([Kx,Ky]) else: Kx = K[0] Ky = K[1] detKY = detY*K alpha = myArctan(detX[0],detX[1]) - myArctan(detKY[0],detKY[1]) A = array([[sp.cos(alpha),sp.sin(alpha)],[-sp.sin(alpha),sp.cos(alpha)]]) X01 = X1 - dot(linalg.inv(A),Y1*K) X02 = X2 - dot(linalg.inv(A),Y2*K) X0 = (X01+X02) /2 return A,X0,K
def elaz2radec_lst(el, az, lst, lat = 38.43312) :
"""DO NOT USE THIS ROUTINE FOR ANTHING THAT NEEDS TO BE RIGHT. IT DOES NOT
CORRECT FOR PRECESSION.
Calculates the Ra and Dec from elavation, aximuth, LST and Latitude.
This function is vectorized with numpy so should be fast. Standart numpy
broadcasting should also work.
All angles in degrees, lst in seconds. Latitude defaults to GBT.
"""
# Convert everything to radians.
el = sp.radians(el)
az = sp.radians(az)
lst = sp.array(lst, dtype = float)*2*sp.pi/86400
lat = sp.radians(lat)
# Calculate dec.
dec = sp.arcsin(sp.sin(el)*sp.sin(lat) +
sp.cos(el)*sp.cos(lat)*sp.cos(az))
# Calculate the hour angle
ha = sp.arccos((sp.sin(el) - sp.sin(lat)*sp.sin(dec)) /
(sp.cos(lat)*sp.cos(dec)))
ra = sp.degrees(lst - ha) % 360
return ra, sp.degrees(dec)
def sparse_orth(d):
""" Constructs a sparse orthogonal matrix.
The method is described in:
Gi-Sang Cheon et al., Constructions for the sparsest orthogonal matrices,
Bull. Korean Math. Soc 36 (1999) No.1 pp.199-129
"""
from scipy.sparse import eye
from scipy import r_, pi, sin, cos
if d % 2 == 0:
seq = r_[0:d:2, 1:d - 1:2]
else:
seq = r_[0:d - 1:2, 1:d:2]
Q = eye(d, d).tocsc()
for i in seq:
theta = random() * 2 * pi
flip = (random() - 0.5) > 0;
Qi = eye(d, d).tocsc()
Qi[i, i] = cos(theta)
Qi[(i + 1), i] = sin(theta)
if flip > 0:
Qi[i, (i + 1)] = -sin(theta)
Qi[(i + 1), (i + 1)] = cos(theta)
else:
Qi[i, (i + 1)] = sin(theta)
Qi[(i + 1), (i + 1)] = -cos(theta)
Q = Q * Qi;
return Q
def trig_func(y, t):
ydot = scipy.zeros(1, scipy.float_)
ydot[0] = scipy.cos(t)
return ydot
def req_noise(xyzsource, d_inch, P_h, T, B, RPM, h, r, CG, PWL_req):
SPL_req = PWL_to_SPL(PWL_req, r)
print(SPL_req)
SPLlst = list()
R_ft = 0.0833333333 * d_inch / 2
m = 1
gamma, R, Temp = 1.4, 287, isa(h)[1]
M_t = V_r(RPM, d_inch, 1) * 0.3048 / np.sqrt(gamma * R * Temp)
V_07 = V_r(RPM, d_inch, 0.7)
#Assumption blade area
A_b = 2 / B * 1 / 12
thetalst = list()
for theta in np.arange(0, 360 + 1, 1):
x = r * np.sin(theta)
y = r * np.cos(theta)
thetalst.append(theta)
xyzobserver = [x, y, 0]
S, theta = position(xyzsource, xyzobserver)
p_rn = list()
p_v = list()
for S, theta in zip(S, theta):
#ORDERED ROTATIONAL NOISE PRESSURE AT OBSERVER
rotationp = p_m(m, S, R_ft, P_h, T, B, M_t, theta)
p_rn.append(rotationp)
#VORTEX NOISE AT OBSERVER
vortexSPL = SPL_vortex(A_b, V_07)
vortexSPL_obs = SPL_to_PWL_dist(vortexSPL, 300, S_obs=S)
vortexp = SPL_to_p(vortexSPL_obs)
p_v.append(vortexp)
p_sum = sum(p_rn + p_v)
SPL = p_to_SPL(p_sum)
SPLlst.append(SPL)
return max(SPLlst), thetalst, SPLlst
#BUTTERFLY PLOT
#plst=list()
#thetalst=list()
#for theta in np.arange(0,2*np.pi*1.026,0.05):
# p=p_m(1,3,0.645833333075,1.36,12.521858094085683,3, 0.75, theta)
# if p>0:
# thetalst.append(theta)
# plst.append(p)
# else:
# thetalst.append(theta)
# plst.append(-p)
#
#plt.plot(thetalst,plst)
#plt.polar(thetalst,plst)
#plt.show()
#plt.ylabel('p')
#plt.xlabel('theta')
def gettrack_roms(jdmat_m, lon_v, lat_v, u, v, startdate, numdays, daystep, la,
lo): # tracks particle at surface
# calculate the points near la,lo
distance, index_location = nearxy(lon_v, lat_v, lo, la)
####### get index of startdate in jdmat_m#####
jdmat_m_num = [] # this is the date in the form of a number
jdmat_m_list, jdmat = [], []
# convert array to list
for jdmat_m_i in jdmat_m:
jdmat_m_list.append(jdmat_m_i)
for i in jdmat_m_list: # convert time to number
jdmat_m_num.append(i)
dts = date2num(dt.datetime(2001, 1, 1, 0, 0, 0))
jdmat_m = [i + dts for i in jdmat_m]
index_startdate = int(
round(np.interp(startdate, jdmat_m,
range(len(jdmat_m))))) #get the index of startdate
print "index_startdate = ", index_startdate, " inside getreack_roms "
print "the start u's location", index_location
u1 = float(u[index_startdate][index_location])
v1 = float(v[index_startdate][index_location])
if u1 == -999.0: # case of no good data
u1 = 0
v1 = 0
nsteps = scipy.floor(min(numdays, jdmat_m_num[-1]) / daystep)
print "nsteps =", nsteps
uu, vv, lon_k, lat_k, time = [], [], [], [], []
uu.append(u1)
vv.append(v1)
lat_k.append(la)
lon_k.append(lo)
time.append(startdate)
for i in range(1, int(nsteps)):
# first, estimate the particle move to its new position using velocity of previous time steps
lat1 = lat_k[i - 1] + float(
vv[i - 1] * daystep * 24 * 3600) / 1000 / 1.8535 / 60
lon1 = lon_k[i - 1] + float(
uu[i - 1] * daystep * 24 * 3600) / 1000 / 1.8535 / 60 * (
scipy.cos(float(lat_k[i - 1])) / 180 * np.pi)
# find the closest model time for the new timestep
jdmat_m_num_i = time[i - 1] + daystep
time.append(jdmat_m_num_i)
if jdmat_m_num_i > max(jdmat_m_num):
print "This time is not available in the model"
index_startdate = int(
round(
np.interp(jdmat_m_num_i, jdmat_m_num,
range(len(jdmat_m_num)))))
#find the point's index of near lat1,lon1
index_location = nearxy(lon_v, lat_v, lon1, lat1)[1]
ui = u[index_startdate][index_location]
vi = v[index_startdate][index_location]
vv.append(vi)
uu.append(ui)
# estimate the particle move from its new position using velocity of previous time steps
lat_k.append(
float(lat1 + lat_k[i - 1] +
float(vv[i] * daystep * 24 * 3600) / 1000 / 1.8535 / 60) / 2)
lon_k.append(
float(lon1 + lon_k[i - 1] +
float(uu[i] * daystep * 24 * 3600) / 1000 / 1.8535 / 60 *
scipy.cos(float(lat_k[i]) / 180 * np.pi)) / 2)
return lat_k, lon_k, time
def HoG(img,
See_graph=False,
cell_per_blk=(3, 3),
pix_per_cell=(5, 5),
orientation=9):
"""
The function for computing Histogram of oriented gradients. Takes
the following as keyword arguments:
cell_per_blk:
How may cells in a block ( cells in height, cells in width)
pix_per_cell:
The size of each cell: ( height, witdh )
orientation:
Binning the gradient into how many orientation bins
"""
if img is None:
print " pic read failed"
return -1
if img.ndim > 3:
print " gray-scale process only for speed performance"
return -1
# gradient computation
gradient_x = np.zeros(img.shape)
gradient_y = np.zeros(img.shape)
gradient_x[:, :-1] = np.diff(img, n=1, axis=1)
gradient_y[:-1, :] = np.diff(img, n=1, axis=0)
magnitude = sqrt(gradient_x**2 + gradient_y**2)
ori = arctan2(gradient_y, (gradient_x + 1e-15)) * (180 / pi) + 90
# Orientation Binning
img_h, img_w = img.shape
cx, cy = pix_per_cell
bx, by = cell_per_blk
ncell_x = int(np.floor(img_w // cx))
ncell_y = int(np.floor(img_h // cy))
ori_histogram = np.zeros((ncell_y, ncell_x, orientation))
for i in range(0, orientation):
temp1 = np.where(ori < 180 / orientation * (i + 1), ori, 0)
temp1 = np.where(ori >= 180 / orientation * i, temp1, 0)
temp2 = np.where(temp1 > 0, magnitude, 0)
ori_histogram[:, :, i] = uniform_filter(temp2,
size=(cy, cx))[cy / 2::cy,
cx / 2::cx]
# display output if required
if See_graph is True:
from skimage import draw
hog_image = np.zeros(img.shape, dtype=float)
radius = min(cx, cy) // 2 - 1
print "Drawing HOG output..."
for x in range(ncell_x):
for y in range(ncell_y):
for o in range(orientation):
centre = tuple([y * cy + cy // 2, x * cx + cx // 2])
dx = radius * cos(float(o) / orientation * np.pi)
dy = radius * sin(float(o) / orientation * np.pi)
rr, cc = draw.line(int(centre[0] - dx),
int(centre[1] - dy),
int(centre[0] + dx),
int(centre[1] + dy))
hog_image[rr, cc] += ori_histogram[y, x, o]
cv2.imshow('HoG img', hog_image)
cv2.waitKey(0)
cv2.destroyAllWindows()
# normalization
n_blocksx = (ncell_x - bx) + 1
n_blocksy = (ncell_y - by) + 1
normalised_blocks = np.zeros((n_blocksy, n_blocksx, by, bx, orientation))
for x in range(n_blocksx):
for y in range(n_blocksy):
block = ori_histogram[y:y + by, x:x + bx, :]
eps = 1e-5
normalised_blocks[y, x, :] = block / sqrt(block.sum()**2 + eps)
return normalised_blocks
def leastSquaresModel(self, tilt_series_list):
phi, optical_axis, z0 = self.getCurrentParameters()
if self.fixed_model == True:
phi = self.phi0
optical_axis = self.offset0
parameters = [phi, optical_axis]
args_list = []
current_tilt_group = self.getCurrentTiltGroup()
current_tilt_direction = current_tilt_group.is_plus_tilt
current_tilt = current_tilt_group.tilts[-1]
datalimit = self.fitdata
if len(current_tilt_group) >= datalimit:
previous_tilts = current_tilt_group.tilts[-datalimit:]
else:
previous_tilts = current_tilt_group.tilts[:]
if self.fixed_model:
# Accept accurate tilts only for fixed phi, offset fitting of z0
tolerance = 0.01
else:
# With all three parameters free to change, use all tilt points to stablize the fiting
# The result is more an average phi, offset.
tolerance = 1.62
tiltmin = min(previous_tilts) - tolerance
tiltmax = max(previous_tilts) + tolerance
for tilt_series in tilt_series_list:
for tilt_group in tilt_series.tilt_groups:
if len(tilt_group.tilts) == 0 or len(tilt_group.xs) != len(
tilt_group.tilts) or len(tilt_group.ys) != len(
tilt_group.tilts):
break
# wrong direction tilt group should not be included in the fit
elif tilt_group.is_plus_tilt is not current_tilt_direction:
continue
parameters.extend([0])
acceptableindices = self.acceptableindices(
tilt_group.tilts, tiltmin, tiltmax, datalimit)
goodtilts = []
goodxs = []
goodys = []
for i in acceptableindices:
goodtilts.append(tilt_group.tilts[i])
goodxs.append(tilt_group.xs[i])
goodys.append(tilt_group.ys[i])
tilts = scipy.array(goodtilts)
cos_tilts = scipy.cos(tilts)
sin_tilts = scipy.sin(tilts)
x0 = tilt_group.xs[0]
y0 = tilt_group.ys[0]
x = scipy.array(goodxs)
y = scipy.array(goodys)
args_list.append((cos_tilts, sin_tilts, x0, y0, x, y))
# leastsq function gives improper parameters error if too many input data array are empty
# This happens if 6 or more preceeding tilt series have much lower end tilt angle
# than the current. We will ignore them.
if cos_tilts.size < 1:
args_list.pop()
parameters.pop()
args = (args_list, )
kwargs = {
'args': args,
#'full_output': 1,
#'ftol': 1e-12,
#'xtol': 1e-12,
}
result = scipy.optimize.leastsq(self.residuals, parameters, **kwargs)
try:
x = list(result[0])
except TypeError:
x = [result[0]]
return x
def Rotate2D(pts, cnt, ang=scipy.pi / 4):
'''pts = {} Rotates points(nx2) about center cnt(2) by angle ang(1) in radian'''
return scipy.dot(
pts - cnt,
ar([[scipy.cos(ang), scipy.sin(ang)],
[-scipy.sin(ang), scipy.cos(ang)]])) + cnt
def hog(image,
orientations=9,
pixels_per_cell=(8, 8),
cells_per_block=(3, 3),
visualise=False,
normalise=False):
"""Extract Histogram of Oriented Gradients (HOG) for a given image.
Compute a Histogram of Oriented Gradients (HOG) by
1) (optional) global image normalisation
2) computing the gradient image in x and y
3) computing gradient histograms
3) normalising across blocks
4) flattening into a feature vector
Parameters
----------
image : (M, N) ndarray
Input image (greyscale).
orientations : int
Number of orientation bins.
pixels_per_cell : 2 tuple (int, int)
Size (in pixels) of a cell.
cells_per_block : 2 tuple (int,int)
Number of cells in each block.
visualise : bool, optional
Also return an image of the HOG.
normalise : bool, optional
Apply power law compression to normalise the image before
processing.
Returns
-------
newarr : ndarray
HOG for the image as a 1D (flattened) array.
hog_image : ndarray (if visualise=True)
A visualisation of the HOG image.
References
----------
* http://en.wikipedia.org/wiki/Histogram_of_oriented_gradients
* Dalal, N and Triggs, B, Histograms of Oriented Gradients for
Human Detection, IEEE Computer Society Conference on Computer
Vision and Pattern Recognition 2005 San Diego, CA, USA
"""
image = np.atleast_2d(image)
"""
The first stage applies an optional global image normalisation
equalisation that is designed to reduce the influence of illumination
effects. In practice we use gamma (power law) compression, either
computing the square root or the log of each colour channel.
Image texture strength is typically proportional to the local surface
illumination so this compression helps to reduce the effects of local
shadowing and illumination variations.
"""
if image.ndim > 3:
raise ValueError("Currently only supports grey-level images")
if normalise:
image = sqrt(image)
"""
The second stage computes first order image gradients. These capture
contour, silhouette and some texture information, while providing
further resistance to illumination variations. The locally dominant
colour channel is used, which provides colour invariance to a large
extent. Variant methods may also include second order image derivatives,
which act as primitive bar detectors - a useful feature for capturing,
e.g. bar like structures in bicycles and limbs in humans.
"""
gx = np.zeros(image.shape)
gy = np.zeros(image.shape)
gx[:, :-1] = np.diff(image, n=1, axis=1)
gy[:-1, :] = np.diff(image, n=1, axis=0)
"""
The third stage aims to produce an encoding that is sensitive to
local image content while remaining resistant to small changes in
pose or appearance. The adopted method pools gradient orientation
information locally in the same way as the SIFT [Lowe 2004]
feature. The image window is divided into small spatial regions,
called "cells". For each cell we accumulate a local 1-D histogram
of gradient or edge orientations over all the pixels in the
cell. This combined cell-level 1-D histogram forms the basic
"orientation histogram" representation. Each orientation histogram
divides the gradient angle range into a fixed number of
predetermined bins. The gradient magnitudes of the pixels in the
cell are used to vote into the orientation histogram.
"""
magnitude = sqrt(gx**2 + gy**2)
orientation = arctan2(gy, (gx + 1e-15)) * (180 / pi) + 90
sx, sy = image.shape
cx, cy = pixels_per_cell
bx, by = cells_per_block
n_cellsx = int(np.floor(sx // cx)) # number of cells in x
n_cellsy = int(np.floor(sy // cy)) # number of cells in y
# compute orientations integral images
orientation_histogram = np.zeros((n_cellsx, n_cellsy, orientations))
for i in range(orientations):
#create new integral image for this orientation
# isolate orientations in this range
temp_ori = np.where(orientation < 180 / orientations * (i + 1),
orientation, 0)
temp_ori = np.where(orientation >= 180 / orientations * i, temp_ori, 0)
# select magnitudes for those orientations
cond2 = temp_ori > 0
temp_mag = np.where(cond2, magnitude, 0)
orientation_histogram[:, :,
i] = uniform_filter(temp_mag,
size=(cx, cy))[cx / 2::cx,
cy / 2::cy].T
# now for each cell, compute the histogram
#orientation_histogram = np.zeros((n_cellsx, n_cellsy, orientations))
radius = min(cx, cy) // 2 - 1
hog_image = None
if visualise:
hog_image = np.zeros((sy, sx), dtype=float)
if visualise:
from skimage import draw
for x in range(n_cellsx):
for y in range(n_cellsy):
for o in range(orientations):
centre = tuple([y * cy + cy // 2, x * cx + cx // 2])
dx = radius * cos(float(o) / orientations * np.pi)
dy = radius * sin(float(o) / orientations * np.pi)
rr, cc = draw.bresenham(centre[0] - dx, centre[1] - dy,
centre[0] + dx, centre[1] + dy)
hog_image[rr, cc] += orientation_histogram[x, y, o]
"""
The fourth stage computes normalisation, which takes local groups of
cells and contrast normalises their overall responses before passing
to next stage. Normalisation introduces better invariance to illumination,
shadowing, and edge contrast. It is performed by accumulating a measure
of local histogram "energy" over local groups of cells that we call
"blocks". The result is used to normalise each cell in the block.
Typically each individual cell is shared between several blocks, but
its normalisations are block dependent and thus different. The cell
thus appears several times in the final output vector with different
normalisations. This may seem redundant but it improves the performance.
We refer to the normalised block descriptors as Histogram of Oriented
Gradient (HOG) descriptors.
"""
n_blocksx = (n_cellsx - bx) + 1
n_blocksy = (n_cellsy - by) + 1
normalised_blocks = np.zeros((n_blocksx, n_blocksy, bx, by, orientations))
for x in range(n_blocksx):
for y in range(n_blocksy):
block = orientation_histogram[x:x + bx, y:y + by, :]
eps = 1e-5
normalised_blocks[x, y, :] = block / sqrt(block.sum()**2 + eps)
"""
The final step collects the HOG descriptors from all blocks of a dense
overlapping grid of blocks covering the detection window into a combined
feature vector for use in the window classifier.
"""
if visualise:
return normalised_blocks.ravel(), hog_image
else:
return normalised_blocks.ravel()
def hof(flow, orientations=9, pixels_per_cell=(8, 8),
cells_per_block=(3, 3), visualise=False, normalise=False, motion_threshold=1.):
"""Extract Histogram of Optical Flow (HOF) for a given image.
Key difference between this and HOG is that flow is MxNx2 instead of MxN
Compute a Histogram of Optical Flow (HOF) by
1. (optional) global image normalisation
2. computing the dense optical flow
3. computing flow histograms
4. normalising across blocks
5. flattening into a feature vector
Parameters
----------
Flow : (M, N) ndarray
Input image (x and y flow images).
orientations : int
Number of orientation bins.
pixels_per_cell : 2 tuple (int, int)
Size (in pixels) of a cell.
cells_per_block : 2 tuple (int,int)
Number of cells in each block.
visualise : bool, optional
Also return an image of the hof.
normalise : bool, optional
Apply power law compression to normalise the image before
processing.
static_threshold : threshold for no motion
Returns
-------
newarr : ndarray
hof for the image as a 1D (flattened) array.
hof_image : ndarray (if visualise=True)
A visualisation of the hof image.
References
----------
* http://en.wikipedia.org/wiki/Histogram_of_oriented_gradients
* Dalal, N and Triggs, B, Histograms of Oriented Gradients for
Human Detection, IEEE Computer Society Conference on Computer
Vision and Pattern Recognition 2005 San Diego, CA, USA
"""
flow = np.atleast_2d(flow)
"""
-1-
The first stage applies an optional global image normalisation
equalisation that is designed to reduce the influence of illumination
effects. In practice we use gamma (power law) compression, either
computing the square root or the log of each colour channel.
Image texture strength is typically proportional to the local surface
illumination so this compression helps to reduce the effects of local
shadowing and illumination variations.
"""
if flow.ndim < 3:
raise ValueError("Requires dense flow in both directions")
if normalise:
flow = sqrt(flow)
"""
-2-
The second stage computes first order image gradients. These capture
contour, silhouette and some texture information, while providing
further resistance to illumination variations. The locally dominant
colour channel is used, which provides colour invariance to a large
extent. Variant methods may also include second order image derivatives,
which act as primitive bar detectors - a useful feature for capturing,
e.g. bar like structures in bicycles and limbs in humans.
"""
if flow.dtype.kind == 'u':
# convert uint image to float
# to avoid problems with subtracting unsigned numbers in np.diff()
flow = flow.astype('float')
gx = np.zeros(flow.shape[:2])
gy = np.zeros(flow.shape[:2])
# gx[:, :-1] = np.diff(flow[:,:,1], n=1, axis=1)
# gy[:-1, :] = np.diff(flow[:,:,0], n=1, axis=0)
gx = flow[:, :, 1]
gy = flow[:, :, 0]
"""
-3-
The third stage aims to produce an encoding that is sensitive to
local image content while remaining resistant to small changes in
pose or appearance. The adopted method pools gradient orientation
information locally in the same way as the SIFT [Lowe 2004]
feature. The image window is divided into small spatial regions,
called "cells". For each cell we accumulate a local 1-D histogram
of gradient or edge orientations over all the pixels in the
cell. This combined cell-level 1-D histogram forms the basic
"orientation histogram" representation. Each orientation histogram
divides the gradient angle range into a fixed number of
predetermined bins. The gradient magnitudes of the pixels in the
cell are used to vote into the orientation histogram.
"""
magnitude = sqrt(gx ** 2 + gy ** 2)
orientation = arctan2(gy, gx) * (180 / pi) % 180
sy, sx = flow.shape[:2]
cx, cy = pixels_per_cell
bx, by = cells_per_block
n_cellsx = int(np.floor(sx // cx)) # number of cells in x
n_cellsy = int(np.floor(sy // cy)) # number of cells in y
# compute orientations integral images
orientation_histogram = np.zeros((n_cellsy, n_cellsx, orientations))
subsample = np.index_exp[int(cy / 2):cy * n_cellsy:cy, int(cx / 2):cx * n_cellsx:cx]
for i in range(orientations - 1):
# create new integral image for this orientation
# isolate orientations in this range
temp_ori = np.where(orientation < 180 / orientations * (i + 1),
orientation, -1)
temp_ori = np.where(orientation >= 180 / orientations * i,
temp_ori, -1)
# select magnitudes for those orientations
cond2 = (temp_ori > -1) * (magnitude > motion_threshold)
temp_mag = np.where(cond2, magnitude, 0)
temp_filt = uniform_filter(temp_mag, size=(cy, cx))
orientation_histogram[:, :, i] = temp_filt[subsample]
''' Calculate the no-motion bin '''
temp_mag = np.where(magnitude <= motion_threshold, magnitude, 0)
temp_filt = uniform_filter(temp_mag, size=(cy, cx))
orientation_histogram[:, :, -1] = temp_filt[subsample]
# now for each cell, compute the histogram
hof_image = None
if visualise:
from skimage import draw
radius = min(cx, cy) // 2 - 1
hof_image = np.zeros((sy, sx), dtype=float)
for x in range(n_cellsx):
for y in range(n_cellsy):
for o in range(orientations - 1):
centre = tuple([y * cy + cy // 2, x * cx + cx // 2])
dx = int(radius * cos(float(o) / orientations * np.pi))
dy = int(radius * sin(float(o) / orientations * np.pi))
rr, cc = draw.bresenham(centre[0] - dy, centre[1] - dx,
centre[0] + dy, centre[1] + dx)
hof_image[rr, cc] += orientation_histogram[y, x, o]
"""
The fourth stage computes normalisation, which takes local groups of
cells and contrast normalises their overall responses before passing
to next stage. Normalisation introduces better invariance to illumination,
shadowing, and edge contrast. It is performed by accumulating a measure
of local histogram "energy" over local groups of cells that we call
"blocks". The result is used to normalise each cell in the block.
Typically each individual cell is shared between several blocks, but
its normalisations are block dependent and thus different. The cell
thus appears several times in the final output vector with different
normalisations. This may seem redundant but it improves the performance.
We refer to the normalised block descriptors as Histogram of Oriented
Gradient (hog) descriptors.
"""
n_blocksx = (n_cellsx - bx) + 1
n_blocksy = (n_cellsy - by) + 1
normalised_blocks = np.zeros((n_blocksy, n_blocksx,
by, bx, orientations))
for x in range(n_blocksx):
for y in range(n_blocksy):
block = orientation_histogram[y:y + by, x:x + bx, :]
eps = 1e-5
normalised_blocks[y, x, :] = block / sqrt(block.sum() ** 2 + eps)
"""
The final step collects the hof descriptors from all blocks of a dense
overlapping grid of blocks covering the detection window into a combined
feature vector for use in the window classifier.
"""
if visualise:
return normalised_blocks.ravel(), hof_image
else:
shape = normalised_blocks.shape
return normalised_blocks.reshape(shape[0], shape[1], (shape[2]*shape[3]*shape[4]))
import numpy as np
fig = plt.figure()
ax = fig.gca(projection='3d')
X = phis_far_field * pi / 180.
Y = thetas_far_field * pi / 180.
#X, Y = np.meshgrid(X, Y)
#surf = ax.plot_surface(X, Y, sigma_theta+sigma_phi, rstride=1, cstride=1, cmap=cm.coolwarm, linewidth=0, antialiased=False)
#ax.zaxis.set_major_locator(LinearLocator(10))
#ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
#fig.colorbar(surf, shrink=0.5, aspect=5)
#plt.show()
phis, thetas = np.meshgrid(X, Y)
SIGMA = sigma_phi + sigma_theta
SIGMA = SIGMA / amax(SIGMA)
X = SIGMA * cos(phis) * sin(thetas)
Y = SIGMA * sin(phis) * sin(thetas)
Z = SIGMA * cos(thetas)
surf = ax.plot_surface(X,
Y,
Z,
rstride=1,
cstride=1,
cmap=cm.jet,
linewidth=0.2)
ax.zaxis.set_major_locator(LinearLocator(10))
ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
fig.colorbar(surf, shrink=0.5, aspect=5)
ax.set_xlabel('X axis')
ax.set_ylabel('Y axis')
ax.set_zlabel('Z axis')
def rotate_vecs(x, y, angle):
xrot = x * scipy.cos(angle) - y * scipy.sin(angle)
yrot = x * scipy.sin(angle) + y * scipy.cos(angle)
return xrot, yrot
def rotation_matrix(angle):
A = scipy.array([[scipy.cos(angle), -scipy.sin(angle)],
[scipy.sin(angle), scipy.cos(angle)]])
return A
def radar_cross_section(frequency, theta, phi, An, Bn):
"""
Calculate the radar cross section for a stratified sphere.
:param frequency: The frequency of the incident wave (Hz).
:param theta: The observation angle theta (rad).
:param phi: The observation angle phi (rad).
:param An: Scattering coefficient.
:param Bn:Scattering coefficient.
:return: The radar cross section for a stratified sphere.
"""
# Wavelength
wavelength = c / frequency
# Wavenumber
k = 2.0 * pi / wavelength
st = abs(sin(theta))
ct = cos(theta)
# Associated Legendre Polynomial
p_lm = zeros(len(An) + 1)
p_lm[0] = -st
p_lm[1] = -3.0 * st * ct
s1 = 0
s2 = 0
p = p_lm[0]
for i_mode in range(1, len(An) + 1):
# Derivative of associated Legendre Polynomial
if abs(ct) < 0.999999999:
if i_mode == 1:
dp = ct * p_lm[0] / sqrt(1.0 - ct**2)
else:
dp = (i_mode * ct * p_lm[i_mode - 1] -
(i_mode + 1.0) * p_lm[i_mode - 2]) / sqrt(1.0 - ct**2)
if st > 1.0e-9:
t1 = An[i_mode - 1] * p / st
t2 = Bn[i_mode - 1] * p / st
if ct > 0.999999999:
val = 1j**(i_mode - 1) * (i_mode * (i_mode + 1.0) / 2.0) * (
An[i_mode - 1] - 1j * Bn[i_mode - 1])
s1 += val
s2 += val
elif ct < -0.999999999:
val = (-1j)**(i_mode - 1) * (i_mode * (i_mode + 1.0) / 2.0) * (
An[i_mode - 1] + 1j * Bn[i_mode - 1])
s1 += val
s2 -= val
else:
s1 += 1j**(i_mode + 1) * (t1 - 1j * Bn[i_mode - 1] * dp)
s2 += 1j**(i_mode + 1) * (An[i_mode - 1] * dp - 1j * t2)
# Recurrence relationship for nex Associated Legendre Polynomial
if i_mode > 1:
p_lm[i_mode] = (2.0 * i_mode +
1.0) * ct * p_lm[i_mode - 1] / i_mode - (
i_mode + 1.0) * p_lm[i_mode - 2] / i_mode
p = p_lm[i_mode]
rcs_th = s1 * cos(radians(phi)) * sqrt(4.0 * pi) / k
rcs_ph = -s2 * sin(radians(phi)) * sqrt(4.0 * pi) / k
return rcs_th, rcs_ph
def predict(self, tilt):
n_start_fit = 3
tilt_series = self.getCurrentTiltSeries()
tilt_group = self.getCurrentTiltGroup()
current_tilt_direction = tilt_group.is_plus_tilt
n_tilt_series = len(self.valid_tilt_series_list)
n_tilt_groups = len(tilt_series)
n_tilts = len(tilt_group)
n = []
gmaxtilt = []
gmintilt = []
for s in self.valid_tilt_series_list:
for g in s.tilt_groups:
if g.is_plus_tilt is not current_tilt_direction:
continue
n.append(len(g))
# old tilts may be aborted before start and therefore tilts=[]
if len(g.tilts) > 0:
gmaxtilt.append(max(g.tilts))
gmintilt.append(min(g.tilts))
maxtilt = max(gmaxtilt)
mintilt = min(gmintilt)
parameters = self.getCurrentParameters()
if n_tilts < 1:
raise RuntimeError
elif n_tilts < 2:
if len(self.tilt_series_list) != len(self.valid_tilt_series_list):
print "%s out of %s tilt series are used in prediction" % (len(
self.valid_tilt_series_list), len(self.tilt_series_list))
x, y = tilt_group.xs[-1], tilt_group.ys[-1]
z = 0.0
# calculate real z correction with current parameters
elif n_tilts < n_start_fit:
x, y = tilt_group.xs[-1], tilt_group.ys[-1]
x0 = tilt_group.xs[0]
y0 = tilt_group.ys[0]
tilt0 = tilt_group.tilts[0]
cos_tilts = scipy.cos(scipy.array([tilt0, tilt]))
sin_tilts = scipy.sin(scipy.array([tilt0, tilt]))
parameters = self.getCurrentParameters()
args_list = [(cos_tilts, sin_tilts, x0, y0, None, None)]
result = self.model(parameters, args_list)
z0 = parameters[2]
z = result[-1][-1][2] - z0
x = result[-1][-1][0]
y = result[-1][-1][1]
else:
if n_tilts != n_start_fit:
self.forcemodel = False
else:
r2 = [0, 0]
r2[0] = abs(
self._getCorrelationCoefficient(tilt_group.tilts[1:],
tilt_group.xs[1:]))
r2[1] = abs(
self._getCorrelationCoefficient(tilt_group.tilts[1:],
tilt_group.ys[1:]))
r2xy = abs(
self._getCorrelationCoefficient(tilt_group.xs[1:],
tilt_group.ys[1:]))
if max(r2) > 0.95 and r2xy > 0.95 and not self.fixed_model:
self.forcemodel = True
else:
self.forcemodel = False
# x,y is only a smooth polynomial fit
x, y = self.leastSquaresXY(tilt_group.tilts, tilt_group.xs,
tilt_group.ys, tilt)
# tilt_group.addTilt(tilt, x, y)
## calculate optical axis tilt and offset
if (abs(maxtilt) < math.radians(30)
and abs(mintilt) < math.radians(30)):
## optical axis offset fit is not reliable at small tilts
orig_fixed_model = self.fixed_model
self.fixed_model = True
self.calculate()
self.fixed_model = orig_fixed_model
else:
self.calculate()
# del tilt_group.tilts[-1]
# del tilt_group.xs[-1]
# del tilt_group.ys[-1]
x0 = tilt_group.xs[0]
y0 = tilt_group.ys[0]
tilt0 = tilt_group.tilts[0]
cos_tilts = scipy.cos(scipy.array([tilt0, tilt]))
sin_tilts = scipy.sin(scipy.array([tilt0, tilt]))
parameters = self.getCurrentParameters()
args_list = [(cos_tilts, sin_tilts, x0, y0, None, None)]
result = self.model(parameters, args_list)
z0 = result[-1][0][2]
z = result[-1][-1][2] - z0
phi, offset = self.convertparams(self.parameters[0],
self.parameters[1])
result = {
'x': float(x),
'y': float(y),
'z': float(z),
'phi': float(phi),
'optical axis': float(offset),
'z0': float(self.parameters[-1]),
}
return result
def number_of_muons_gradient(fita, sigma_s, sigma_o, k):
# Function to integrate- return number of muons as a function of s I do not use it anymore
return (k * (sigma_s * (1 + sp.cos(fita) * sp.cos(fita)) +
(sigma_o * sp.cos(fita))))
import scipy as sp
import scipy.misc
import scipy.constants
from scipy import pi
if __name__ == "__main__" and __package__ is None:
sys.path.append('..')
__package__ = "doamusic"
import doamusic
from doamusic import music
from doamusic import _music
from doamusic import util
# 16 element unit circle in the y-z plane
antx = sp.arange(16)
circarray = sp.array([0 * antx, sp.cos(antx), sp.sin(antx)]).T
# 3 offset circles in planes parallel to y-z
front = circarray + [1, 0, 0]
back = circarray - [1, 0, 0]
triplecircarray = sp.concatenate((front, circarray, back))
# unit spacing grid (5x5)
gridarray = sp.array([(0, y, z)
for y, z in itertools.product(range(-3, 4), repeat=2)])
# unit spacing linear
linarray = sp.array([(0, y, 0) for y in range(10)])
# Arrays as constructed.
operating_frequency = 2.477e9
def _update_canvas(self):
"""
Update the figure when the user changes an input value.
:return:
"""
seterr(divide='ignore')
# Generate a sample signal to be used (later used matched filter output)
number_of_samples = 1000
i_noise = rnd.normal(0, 0.05, number_of_samples)
q_noise = rnd.normal(0, 0.05, number_of_samples)
noise_signal = sqrt(i_noise**2 + q_noise**2)
# Create the time array
t = linspace(0.0, 1.0, number_of_samples)
# Create example signal for the CFAR process
s1 = 0.4 * cos(2 * pi * 600 * t) + 1j * 0.4 * sin(2 * pi * 600 * t)
s2 = 0.1 * cos(2 * pi * 150 * t) + 1j * 0.1 * sin(2 * pi * 150 * t)
s3 = 0.2 * cos(2 * pi * 100 * t) + 1j * 0.2 * sin(2 * pi * 100 * t)
# Sum for the example signal
signal = abs(fftpack.fft(s1 + s2 + s3 + noise_signal))
signal[0] = 0
# Get the CFAR type from the form
cfar_type = self.cfar_type.currentText()
# Set up the key word args for the inputs
kwargs = {
'signal': signal,
'guard_cells': int(self.guard_cells.text()),
'reference_cells': int(self.reference_cells.text()),
'bias': float(self.bias.text()),
'cfar_type': cfar_type
}
# Calculate the CFAR threshold
cfar_threshold = cfar(**kwargs)
# Clear the axes for the updated plot
self.axes1.clear()
# Display the results
self.axes1.plot(10.0 * log10(signal), '', label='Signal')
self.axes1.plot(cfar_threshold, 'r--', label='CFAR Threshold')
# Set the plot title and labels
self.axes1.set_title('Constant False Alarm Rate', size=14)
self.axes1.set_ylabel('Signal Strength (dB)', size=12)
self.axes1.set_xlabel('Range (m)', size=12)
self.axes1.set_ylim(-10, 30)
# Set the tick label size
self.axes1.tick_params(labelsize=12)
# Set the legend
self.axes1.legend(loc='upper right', prop={'size': 10})
# Turn on the grid
self.axes1.grid(linestyle=':', linewidth=0.5)
# Update the canvas
self.my_canvas.draw()
def doTrial(cfg):
# set up the target:
targetangle_deg = cfg['tasks'][cfg['taskno']]['target'][cfg['trialno']]
targetangle = (targetangle_deg / 180) * sp.pi
targetpos = [
sp.cos(targetangle) * cfg['targetdistance'],
sp.sin(targetangle) * cfg['targetdistance']
]
cfg['target'].pos = targetpos
# hold home before reach:
holdTime = 0.5
# phase 0: do pre-reach aiming if required:
doAim = cfg['tasks'][cfg['taskno']]['aiming'][cfg['trialno']]
if doAim:
cfg = doAiming(cfg)
aim = cfg['aim']
else:
# if not required: set to correct value for data file:
aim = sp.NaN
# how long does one aiming trial take?
holdTime = holdTime + 1.5
# trials need to know whether or not there is a cursor
showcursor = cfg['tasks'][cfg['taskno']]['cursor'][cfg['trialno']]
# for trials with / without strategy, we should record that:
usestrategy = cfg['tasks'][cfg['taskno']]['strategy'][cfg['trialno']]
# set up rotation matrix for current rotation:
rotation = cfg['tasks'][cfg['taskno']]['rotation'][cfg['trialno']]
theta = (rotation / 180.) * sp.pi
R = sp.array([[sp.cos(theta), -1 * sp.sin(theta)],
[sp.sin(theta), sp.cos(theta)]],
order='C')
trialDone = False
phase = 0
# create lists to store data in:
mouseX = []
mouseY = []
cursorX = []
cursorY = []
time_s = []
while not (trialDone):
[X, Y, T] = cfg['mouse'].getPos()
cursorpos = list(R.dot(sp.array([[X], [Y]])).flatten())
cfg['cursor'].pos = cursorpos
cursorangle = sp.arctan2(cursorpos[1], cursorpos[0])
mouseX.append(X)
mouseY.append(Y)
cursorX.append(cursorpos[0])
cursorY.append(cursorpos[1])
time_s.append(T)
if (phase == 2):
cfg['target'].draw()
if showcursor:
cfg['cursor'].draw()
if (sp.sqrt(
sp.sum((sp.array(cursorpos) - sp.array(targetpos))**
2))) < cfg['radius']:
phase = 3
else:
#print('no-cursor, phase 2')
idx = sp.argmin(abs(sp.array(time_s) + 0.250 - time_s[-1]))
if (sp.sqrt(mouseX[-1]**2 + mouseY[-1]**2)) > (cfg['NSU'] *
.5):
distance = sp.sum(
sp.sqrt(
sp.diff(sp.array([mouseX[idx:]]))**2 +
sp.diff(sp.array([mouseY[idx:]]))**2))
if distance < (0.01 * cfg['NSU']):
phase = 3
if (phase == 1):
#cfg['home'].draw()
cfg['cursor'].draw()
if (time.time() > (phaseOneStart + holdTime)):
# held the home position for long enough, going to phase 2:
phase = 2
if (sp.sqrt(sp.sum(sp.array(cursorpos)**2)) > cfg['radius']):
# hold not maintained, restart phase 0:
phase = 0
if (phase == 0) or (phase == 3):
cfg['home'].draw()
if showcursor:
cfg['cursor'].draw()
else:
#print('no-cursor, phase 1 or 3')
if (sp.sqrt(sum([c**2 for c in cursorpos])) <
(0.15 * cfg['NSU'])):
cfg['cursor'].draw()
else:
# put arrow in home position
grain = (2 * sp.pi) / 8
arrowangle = (((cursorangle -
(grain / 2)) // grain) * grain) + grain
cfg['home_arrow'].ori = ((-1 * arrowangle) / sp.pi) * 180
cfg['home_arrow'].draw()
#print([sp.sqrt(sp.sum(sp.array(cursorpos)**2)), (0.025 * cfg['NSU'])])
if (sp.sqrt(sp.sum(sp.array(cursorpos)**2)) < cfg['radius']):
if phase == 0:
phase = 1
phaseOneStart = time.time()
if phase == 3:
trialDone = True
#cfg['target'].draw()
cfg['win'].flip()
if cfg['keyboard'][key.ESCAPE]:
sys.exit('escape key pressed')
# make data frame and store as csv file...
nsamples = len(time_s)
task_idx = [cfg['taskno'] + 1] * nsamples
trial_idx = [cfg['trialno'] + 1] * nsamples
cutrial_no = [cfg['totrialno'] + 1] * nsamples
targetangle_deg = [targetangle_deg] * nsamples
targetx = [targetpos[0]] * nsamples
targety = [targetpos[1]] * nsamples
rotation_deg = [rotation] * nsamples
doaiming_bool = [cfg['tasks'][cfg['taskno']]['aiming'][cfg['trialno']]
] * nsamples
showcursor_bool = [showcursor] * nsamples
usestrategy_cat = [usestrategy] * nsamples
cutime_ms = [int((t - cfg['expstart']) * 1000) for t in time_s]
time_ms = [t - cutime_ms[0] for t in cutime_ms]
aim_deg = [aim] * nsamples
if sp.isnan(aim):
aimdeviation_deg = aim_deg
aimstart_deg = aim_deg
aimtime_ms = aim_deg
else:
aimdeviation_deg = (aim - targetangle_deg[0]) % 360
if aimdeviation_deg > 180:
aimdeviation_deg = aimdeviation_deg - 360
aimdeviation_deg = [aimdeviation_deg] * nsamples
aimstart_deg = [
targetangle_deg[0] +
cfg['tasks'][cfg['taskno']]['aimoffset'][cfg['trialno']]
] * nsamples
aimtime_ms = [cfg['aimtime_ms']] * nsamples
# put all lists in dictionary:
trialdata = {
'task_idx': task_idx,
'trial_idx': trial_idx,
'cutrial_no': cutrial_no,
'targetangle_deg': targetangle_deg,
'targetx': targetx,
'targety': targety,
'rotation_deg': rotation_deg,
'doaiming_bool': doaiming_bool,
'aimstart_deg': aimstart_deg,
'showcursor_bool': showcursor_bool,
'usestrategy_cat': usestrategy_cat,
'aim_deg': aim_deg,
'aimdeviation_deg': aimdeviation_deg,
'aimtime_ms': aimtime_ms,
'cutime_ms': cutime_ms,
'time_ms': time_ms,
'mousex': mouseX,
'mousey': mouseY,
'cursorx': cursorX,
'cursory': cursorY
}
# make dictionary into data frame:
trialdata = pd.DataFrame(trialdata)
# store data frame:
filename = 'data/%s/p%03d/task%02d-trial%04d.csv' % (
cfg['groupname'], cfg['ID'], cfg['taskno'] + 1, cfg['trialno'] + 1)
trialdata.to_csv(filename, index=False, float_format='%0.5f')
return (cfg)
def peval(self, p, f):
d = self.d
dG = p[0]
al = ((p[1] + 180) % 360 - 180) * sp.pi / 180
ps = ((p[2] + 180) % 360 - 180) * sp.pi / 180
ph = ((p[3] + 180) % 360 - 180) * sp.pi / 180
ep = p[4]
ch = ((p[5] + 180) % 360 - 180) * sp.pi / 180
flux = p[
6] #This is a variable for accounting for the difference in flux.
be = ((p[7] + 180) % 360 - 180) * sp.pi / 180
theta = self.theta
t = self.function
m_tot = sp.zeros((4, 4), float)
m_tot[0, 0] = flux
m_IQ = flux * (0.5 * dG * sp.cos(2. * al) -
2. * ep * sp.cos(ph - ch) * sp.sin(2. * al))
m_IU = flux * (0.5 * dG * sp.sin(2. * al) * sp.cos(ch) + 2 * ep *
(sp.cos(al) * sp.cos(al) * sp.cos(ph) -
sp.sin(al) * sp.sin(al) * sp.cos(ph - 2. * ch)))
m_tot[0, 1] = m_IQ
m_tot[0, 2] = m_IU
m_tot[0,
3] = flux * (0.5 * dG * sp.sin(2. * al) * sp.sin(ch) + 2 * ep *
(sp.cos(al) * sp.cos(al) * sp.sin(ph) +
sp.sin(al) * sp.sin(al) * sp.sin(ph - 2. * ch)))
m_tot[1, 0] = flux * 0.5 * dG
m_QQ = flux * sp.cos(2. * al)
m_QU = flux * sp.sin(2 * al) * sp.cos(ch)
m_tot[1, 1] = m_QQ
m_tot[1, 2] = m_QU
m_tot[1, 3] = flux * sp.sin(2. * al) * sp.sin(ch)
m_tot[2, 0] = flux * 2 * ep * sp.cos(ph + ps)
m_UQ = -flux * sp.sin(2 * al) * sp.cos(ps + ch)
m_UU = flux * (sp.cos(al) * sp.cos(al) * sp.cos(ps) -
sp.sin(al) * sp.sin(al) * sp.cos(ps + 2. * ch))
m_tot[2, 1] = m_UQ
m_tot[2, 2] = m_UU
m_tot[2, 3] = flux * (-sp.cos(al) * sp.cos(al) * sp.sin(ps) -
sp.sin(al) * sp.sin(al) * sp.sin(ps + 2. * ch))
m_tot[3, 0] = flux * 2 * ep * sp.sin(ps + ph)
m_VQ = -flux * sp.sin(2 * al) * sp.sin(ps + ch)
m_VU = flux * (sp.sin(ps) * sp.cos(al) * sp.cos(al) -
sp.sin(al) * sp.sin(al) * sp.sin(ps + 2. * ch))
m_tot[3, 1] = m_VQ
m_tot[3, 2] = m_VU
m_tot[3, 3] = flux * (sp.cos(al) * sp.cos(al) * sp.cos(ps) +
sp.sin(al) * sp.sin(al) * sp.cos(ps + 2. * ch))
M_total = sp.mat(m_tot)
M_total = M_total.I
for i in range(0, len(t), 4):
t[i] = M_total[0, 0] * d[i, f] + M_total[0, 1] * d[
i + 1, f] + M_total[0, 2] * d[i + 2,
f] + M_total[0, 3] * d[i + 3, f]
t[i +
1] = (M_total[1, 0] * sp.cos(2 * theta[i]) -
M_total[2, 0] * sp.sin(2 * theta[i])) * d[i, f] + (
M_total[1, 1] * sp.cos(2 * theta[i]) -
M_total[2, 1] * sp.sin(2 * theta[i])) * d[i + 1, f] + (
M_total[1, 2] * sp.cos(2 * theta[i]) -
M_total[2, 2] * sp.sin(2 * theta[i])
) * d[i + 2, f] + (
M_total[1, 3] * sp.cos(2 * theta[i]) -
M_total[2, 3] * sp.sin(2 * theta[i])) * d[i + 3, f]
t[i +
2] = (M_total[1, 0] * sp.sin(2 * theta[i]) +
M_total[2, 0] * sp.cos(2 * theta[i])) * d[i, f] + (
M_total[1, 1] * sp.sin(2 * theta[i]) +
M_total[2, 1] * sp.cos(2 * theta[i])) * d[i + 1, f] + (
M_total[1, 2] * sp.sin(2 * theta[i]) +
M_total[2, 2] * sp.cos(2 * theta[i])
) * d[i + 2, f] + (
M_total[1, 3] * sp.sin(2 * theta[i]) +
M_total[2, 3] * sp.cos(2 * theta[i])) * d[i + 3, f]
t[i + 3] = M_total[3, 0] * d[i, f] + M_total[3, 1] * d[
i + 1, f] + M_total[3, 2] * d[i + 2,
f] + M_total[3, 3] * d[i + 3, f]
return t
else:
print "plotting only supported for indim=1 or indim=2."
if __name__ == '__main__':
from pylab import figure, show
# --- example on how to use the GP in 1 dimension
ds = SupervisedDataSet(1, 1)
gp = GaussianProcess(indim=1, start=-3, stop=3, step=0.05)
figure()
x = mgrid[-3:3:0.2]
y = 0.1 * x**2 + x + 1
z = sin(x) + 0.5 * cos(y)
ds.addSample(-2.5, -1)
ds.addSample(-1.0, 3)
gp.mean = 0
# new feature "autonoise" adds uncertainty to data depending on
# it's distance to other points in the dataset. not tested much yet.
# gp.autonoise = True
gp.trainOnDataset(ds)
gp.plotCurves(showSamples=True)
# you can also test the gp on single points, but this deletes the
# original testing grid. it can be restored with a call to _buildGrid()
print gp.testOnArray(array([[0.4]]))
def plot_circle(circ, color='k'):
phi = sp.linspace(0, 2 * sp.pi, 100)
xc, yc, r = circ
x = r * sp.cos(phi) + xc
y = r * sp.sin(phi) + yc
pl.plot(x, y, color)
def sec(x):
return 1 / cos(x) # 関数 sec を定義
# array([t, exp(t-t**2)])
N = [2 * n for n in range(100)]
stepsize = []
mean_error = []
result = []
expected = []
# TODO: возможно, стоит сделать тесты автоматизироваными?
for n in N:
stepsize.append((te - t0) / (n + 1))
timeGrid = linspace(t0, te, n + 2)
expected = [
array([
t, -exp(-t / 2) * sin(t * sqrt(3) / 2),
exp(-t / 2) * ((-1 / 2) * sin(t * sqrt(3) / 2) +
(sqrt(3) / 2) * cos(t * sqrt(3) / 2))
]) for t in timeGrid
]
method = Gauss(f, init, t0, te, n)
method.solve()
result = method.solution
print(result)
error = [
norm(expected[i][1:] - result[i][1:]) for i in range(len(timeGrid))
]
mean = np.mean(error)
mean_error.append(mean)
print(mean, error[1])
result = array(result)
expected = array(expected)
X, Y = result[:, 1].flatten(), result[:, 2].flatten()
# définition des paramètres du paquet d'onde inital
x0 = x[Nx/4] # position initiale du paquet
sigma = 2.e-10 # largeur du paquet en m
Lambda = 1.5e-10 # longeur d'onde de de Broglie l'électron (en m)
Ec = (h/Lambda)**2/(2*m_e*e) # énergie cinétique théorique de l'électron (en eV)
# définition des coefficients constants
a1 = -(hbar**2/(2*m_e*e*dx**2))
# initialisation des buffers de calcul aux conditions initiales
Psi_Real = zeros(Nx)
Psi_Imag = zeros(Nx)
Psi_Prob = zeros(Nx)
# calcul de la fonction d'onde initiale
Psi_Real = exp(-0.5*((x-x0)/sigma)**2)*cos(DeuxPi*(x-x0)/Lambda)
Psi_Imag = exp(-0.5*((x-x0)/sigma)**2)*sin(DeuxPi*(x-x0)/Lambda)
# normalisation du paquet d'onde
PsiPsiC = Psi_Real**2 + Psi_Imag**2
C = simps(PsiPsiC,x)
Psi_Real = Psi_Real/sqrt(C)
Psi_Imag = Psi_Imag/sqrt(C)
Psi_Prob = Psi_Real**2 + Psi_Imag**2
# calcul de l'énergie moyenne transportée par le paquet
En = zeros(Nx)
En[1:-1] = a1*(Psi_Real[1:-1] - 1j*Psi_Imag[1:-1]) \
*(Psi_Real[2:] - 2*Psi_Real[1:-1] + Psi_Real[:-2] \
+ 1j*(Psi_Imag[2:] - 2*Psi_Imag[1:-1] + Psi_Imag[:-2]))
Ebarre = simps(En,x)
print "Energie theorique : " + str(Ec) + " eV"
print "Energie moyenne du paquet : " + str(Ebarre.real) + " eV"
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
def sec(x):
return 1 / cos(x) # 関数 sec を定義
u = linspace(0, 2 * pi, 20) # メッシュ作成の変数方位角 θ 周り 0 から 2π，20 等分
v = linspace(0, 2 * pi, 20) # メッシュ作成の変数方位角 φ 周り 0 から 2π，20 等分
epz = 3 # z 方向の誘電率の絶対値 (負の値)
epx = 5 # x 方向の誘電率 (正の値)
uu, vv = meshgrid(u, v) # メッシュの作成
x = sqrt(epz) * sec(uu) * cos(vv) # 屈折率楕円体の媒介変数表示 x 方向
y = sqrt(epz) * sec(uu) * sin(vv) # 屈折率楕円体の媒介変数表示 y 方向
z = sqrt(epx) * tan(uu) # 屈折率楕円体の媒介変数表示 z 方向
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_wireframe(x, y, z) # ワイヤフレームのプロット
ax.set_xlabel('X') # x 方向ラベル
ax.set_ylabel('Y') # y 方向ラベル
ax.set_zlabel('Z') # z 方向ラベル
ax.set_xlim3d(-20, 20) # x 方向プロット範囲
ax.set_ylim3d(-20, 20) # y 方向プロット範囲
ax.set_zlim3d(-30, 30) # z 方向プロット範囲
plt.show() # グラフの表示
## Medium permittivity and permeability ## EPSILON0 = 1 #8.854187817e-12 MU0 = 1 #4 * sp.pi * 1e-7 epsR = EPSILON0 * sp.ones((SIZE_R, SIZE_PHI)) muR = MU0 * sp.ones((SIZE_R, SIZE_PHI)) ## Grid for plotting ## grid = sp.mgrid[0:SIZE_R, 0:SIZE_PHI] # Re-represent the grid values in cartesian coordinates r = sp.array(grid[0], dtype=float) r[0, :] = 0.000001 phi = 2 * grid[1] gridx = r * sp.cos(sp.pi * phi / 180) gridy = r * sp.sin(sp.pi * phi / 180) ## Coordinate-dependent scale factors ## # We define the scale factors at *integral points*. Thus, the position of the # scale factors does not coincide with *any* field point, because the fields # are defined at points which are half-integral in at least one coordinate h_r = sp.ones((SIZE_R, SIZE_PHI)) h_phi = r h_z = sp.ones((SIZE_R, SIZE_PHI)) ## Coefficients for update equations ## # In this section, the notation cA_i_B_j is used to mean the coefficient of the # j-component of B in the update equation for the i-component of A.
def model_plot_track(depth, jdmat_m, lat_vel_1, lon_vel_1, u, v, lat_vel,
lon_vel, h_vel, siglay, startdate, numdays, daystep, x,
la, lo):
fig = plt.figure(1)
if len(depth) == 1:
panels = len(startdate)
if len(depth) != 1:
panels = len(depth)
for j in range(1, panels + 1):
print int(str(panels) + str(2) + str(j))
if panels == 1:
ax = fig.add_subplot(111)
else:
ax = fig.add_subplot(int(str(2) + str(2) + str(j)))
if j == 3:
plt.xlabel('Longitude W')
if j == 1:
plt.ylabel('Latitude N')
for k in range(len(la)):
for m in range(len(lo)):
(distance, index_location) = nearxy(lon_vel_1, lat_vel_1,
lo[m], la[k])
(disth, index_location_h) = nearxy(lon_vel, lat_vel, lo[m],
la[k])
depths = h_vel[index_location_h] * siglay[:, index_location_h]
# make depths to be descending order
new_depths = list(depths)
new_depths.reverse()
# depths range
range_depths = range(len(depths))
range_depths.reverse()
if len(depth) == 1:
idz = 0
else:
idz = int(
round(np.interp(depth[j - 1], new_depths,
range_depths)))
####### get index of startdate in jdmat_m
jdmat_m_num = [] # this is the data in the form of a number
del_list, jdmat, del_index = [], [], []
# convert array to list
jdmat_m_list = [jdmat_m_i for jdmat_m_i in jdmat_m]
# while seconds=60, can change the datetime to number, so delete
for i in range(1, len(jdmat_m_list)):
if jdmat_m_list[i][17:19] == '60' or jdmat_m_list[
i - 1] == jdmat_m_list[i]:
del_list.append(jdmat_m_list[i])
del_index.append(i) #get the index of deleted datetime
jdmat = [val for val in jdmat_m_list if val not in del_list
] # delete the wrong value, jdmat just
for i in jdmat: # convert time to number
jdmat_m_num.append(
date2num(
dt.datetime.strptime(i, '%Y-%m-%dT%H:%M:%S.%f')))
# get index of startdate in jdmat_m_num
index_startdate_1 = int(
round(
np.interp(date2num(startdate[j - 1]), jdmat_m_num,
range(len(jdmat_m_num)))))
if del_index != []:
index_add = int(
np.ceil(
np.interp(index_startdate_1, del_index,
range(len(del_index)))))
index_startdate = index_add + index_startdate_1
else:
index_startdate = index_startdate_1
# get u,v
u1 = float(u[index_startdate, idz, index_location])
v1 = float(v[index_startdate, idz, index_location])
nsteps = scipy.floor(min(numdays, jdmat_m_num[-1]) / daystep)
# get the velocity data at this first time & place
lat_k = 'lat' + str(k)
lon_k = 'lon' + str(k)
uu, vv, lon_k, lat_k, time = [], [], [], [], []
uu.append(u1)
vv.append(v1)
lat_k.append(la[k])
lon_k.append(lo[m])
time.append(date2num(startdate[j - 1]))
for i in range(1, int(nsteps)):
# first, estimate the particle move to its new position using velocity of previous time steps
lat1 = lat_k[i - 1] + float(
vv[i - 1] * daystep * 24 * 3600) / 1000 / 1.8535 / 60
lon1 = lon_k[i - 1] + float(
uu[i - 1] * daystep * 24 * 3600) / 1000 / 1.8535 / 60 * (
scipy.cos(float(lat_k[i - 1])) / 180 * np.pi)
# find the closest model time for the new timestep
jdmat_m_num_i = time[i - 1] + daystep
time.append(jdmat_m_num_i)
index_startdate_1 = int(
round(
np.interp(jdmat_m_num_i, jdmat_m_num,
range(len(jdmat_m_num)))))
if del_index != []:
index_add = int(
np.ceil(
np.interp(index_startdate_1, del_index,
range(len(del_index)))))
index_startdate = index_add + index_startdate_1
else:
index_startdate = index_startdate_1
#find the point's index of near lat1,lon1
index_location = nearxy(lon_vel_1, lat_vel_1, lon1, lat1)[1]
ui = u[index_startdate, 1, index_location]
vi = v[index_startdate, 1, index_location]
vv.append(vi)
uu.append(ui)
# estimate the particle move from its new position using velocity of previous time steps
lat_k.append(
float(lat1 + lat_k[i - 1] +
float(vv[i] * daystep * 24 * 3600) / 1000 / 1.8535 /
60) / 2)
lon_k.append(
float(lon1 + lon_k[i - 1] +
float(uu[i] * daystep * 24 * 3600) / 1000 / 1.8535 /
60 * scipy.cos(float(lat_k[i]) / 180 * np.pi)) / 2)
plt.plot(lon_k,
lat_k,
"-",
linewidth=1,
marker=".",
markerfacecolor='r')
basemap([min(lat_k) - 2, max(lat_k) + 2],
[min(lon_k) - 2, max(lon_k) + 2])
# make same size for the panels
min_lat, max_lon, max_lat, min_lon = [], [], [], []
min_lat.append(min(lat_k))
max_lat.append(max(lat_k))
min_lon.append(min(lon_k))
max_lon.append(max(lon_k))
text1 = ax.annotate(str(num2date(time[0]).month) + "-" +
str(num2date(time[0]).day),
xy=(lon_k[0], lat_k[0]),
xycoords='data',
xytext=(8, 10),
textcoords='offset points',
arrowprops=dict(arrowstyle="->"))
text1.draggable()
text1 = ax.annotate(str(num2date(time[-1]).month) + "-" +
str(num2date(time[-1]).day),
xy=(lon_k[-1], lat_k[-1]),
xycoords='data',
xytext=(8, 10),
textcoords='offset points',
arrowprops=dict(arrowstyle="->"))
#set the numbers formatter
majorFormatter = FormatStrFormatter('%.2f')
ax.yaxis.set_major_formatter(majorFormatter)
ax.xaxis.set_major_formatter(majorFormatter)
if len(depth) == 1:
plt.title(str(num2date(time[i - 1]).year))
else:
plt.title(
str(num2date(time[i - 1]).year) + " year" + " depth: " +
str(depth[j - 1]))
ax.xaxis.set_label_coords(0.5, -0.005) #set the position of the xlabel
ax.yaxis.set_label_coords(-0.1, 0.5)
plt.xlim([min(min_lon), max(max_lon)])
plt.ylim([min(min_lat), max(max_lat)])
plt.show()
def _update_canvas(self):
"""
Update the figure when the user changes an input value
:return:
"""
# Get the parameters from the form
frequency = float(self.frequency.text())
number_of_elements = int(self.number_of_elements.text())
scan_angle_theta = float(self.scan_angle_theta.text())
scan_angle_phi = float(self.scan_angle_phi.text())
radius = float(self.radius.text())
# Set up the theta and phi arrays
n = 360
m = int(n / 8)
theta, phi = meshgrid(linspace(0.0 * pi, 0.5 * pi, n),
linspace(0.0, 2.0 * pi, n))
# Set up the args
kwargs = {
'number_of_elements': number_of_elements,
'scan_angle_theta': radians(scan_angle_theta),
'scan_angle_phi': radians(scan_angle_phi),
'radius': radius,
'frequency': frequency,
'theta': theta,
'phi': phi
}
# Get the array factor
af = circular_uniform.array_factor(**kwargs)
# Remove the color bar
try:
self.cbar.remove()
except:
# Initial plot
pass
# Clear the axes for the updated plot
self.axes1.clear()
# U-V coordinates for plotting the antenna pattern
uu = sin(theta) * cos(phi)
vv = sin(theta) * sin(phi)
if self.plot_type.currentIndex() == 0:
# Display the results
im = self.axes1.pcolor(uu, vv, abs(af), cmap="jet")
self.cbar = self.fig.colorbar(im,
ax=self.axes1,
orientation='vertical')
self.cbar.set_label("Normalized Electric Field (V/m)", size=10)
# Set the x- and y-axis labels
self.axes1.set_xlabel("U (sines)", size=12)
self.axes1.set_ylabel("V (sines)", size=12)
elif self.plot_type.currentIndex() == 1:
# Create the contour plot
self.axes1.contour(uu,
vv,
abs(af),
20,
cmap="jet",
vmin=-0.2,
vmax=1.0)
# Turn on the grid
self.axes1.grid(linestyle=':', linewidth=0.5)
# Set the x- and y-axis labels
self.axes1.set_xlabel("U (sines)", size=12)
self.axes1.set_ylabel("V (sines)", size=12)
else:
# Create the line plot
self.axes1.plot(degrees(theta[0]),
20.0 * log10(abs(af[m])),
'',
label='E Plane')
self.axes1.plot(degrees(theta[0]),
20.0 * log10(abs(af[0])),
'--',
label='H Plane')
# Set the y axis limit
self.axes1.set_ylim(-60, 5)
# Set the x and y axis labels
self.axes1.set_xlabel("Theta (degrees)", size=12)
self.axes1.set_ylabel("Array Factor (dB)", size=12)
# Turn on the grid
self.axes1.grid(linestyle=':', linewidth=0.5)
# Place the legend
self.axes1.legend(loc='upper right', prop={'size': 10})
# Set the plot title and labels
self.axes1.set_title('Circular Array - Array Factor', size=14)
# Set the tick label size
self.axes1.tick_params(labelsize=12)
# Update the canvas
self.my_canvas.draw()
dx = 0.1
t0 = 0.0
tmax = 500.0
dt = 0.1
x = arange(xmin, xmax, dx)
temps = arange(t0, tmax, dt)
# calcul d'une superposition de deux OPPH en milieu non dispersif
omega0 = 1000.0
domega = 1.0
k0 = 0.5
dk = 0.01
#mescourbes=[[2*Psi0*cos(domega*t - dk*xi)*cos(omega0*t - k0*xi) for xi in x] for t in temps]
# calcul d'un paquet d'ondes
mescourbes = [[
2 * Psi0 * sinc(domega * t - dk * xi) * cos(omega0 * t - k0 * xi)
for xi in x
] for t in temps]
# tracé de l'animation
fig = pyplot.figure()
ax = pyplot.axes(xlim=(0, xmax), ylim=(-1.0, 1.0))
courbe, = ax.plot(x, mescourbes[0])
line_ani = animation.FuncAnimation(fig,
traceframe,
100,
interval=50,
repeat=True)
pyplot.show()
def orbitPos(self, t): #exact orbit position as f(t)
x = self.orbitR * sp.cos(self.omega * t + self.theta)
y = self.orbitR * sp.sin(self.omega * t + self.theta)
return sp.array([x, y])
def gettrack_FVCOM(depth, jdmat_m, lat_vel_1, lon_vel_1, u, v, lat_vel,
lon_vel, h_vel, siglay, startdate, numdays, daystep, la,
lo):
"""get the track for models"""
# calculate the points near la,la
(disth, index_location_h) = nearxy(lon_vel, lat_vel, lo, la)
(distance, index_location) = nearxy(lon_vel_1, lat_vel_1, lo, la)
# calculate all the depths
depths = h_vel[index_location_h] * siglay[:, index_location_h]
# make depths to be descending order
new_depths = list(depths).reverse()
# depths range
range_depths = range(len(depths)).reverse()
# calculate the index of depth in the depths
idz = int(round(np.interp(depth, new_depths, range_depths)))
print "the depth index is:", idz
####### get index of startdate in jdmat_m#####
jdmat_m_num = [] # this is the data in the form of a number
del_list, jdmat, del_index = [], [], []
# convert array to list
jdmat_m_list = [jdmat_m_i for jdmat_m_i in jdmat_m]
# while seconds=60, can change the datetime to number, so delete
for i in range(1, len(jdmat_m_list)):
if jdmat_m_list[i][17:19] == '60' or jdmat_m_list[
i - 1] == jdmat_m_list[i]:
del_list.append(jdmat_m_list[i])
del_index.append(i) #get the index of deleted datetime
jdmat = [val for val in jdmat_m_list
if val not in del_list] # delete the wrong value, jdmat just
for i in jdmat: # convert time to number
jdmat_m_num.append(
date2num(dt.datetime.strptime(i, '%Y-%m-%dT%H:%M:%S.%f')))
index_startdate_1 = int(
round(
np.interp(date2num(startdate), jdmat_m_num,
range(len(jdmat_m_num))))) #get the index of startdate
print "the index of start date is:", index_startdate_1
# calculate the delete index of time for u and v
if del_index != []:
index_add = int(
np.ceil(
np.interp(index_startdate_1, del_index,
range(len(del_index)))))
index_startdate = index_add + index_startdate_1
else:
index_startdate = index_startdate_1
# get u,v
u1 = float(u[index_startdate, idz, index_location])
v1 = float(v[index_startdate, idz, index_location])
nsteps = scipy.floor(min(numdays, jdmat_m_num[-1]) / daystep)
# get the velocity data at this first time & place
lat_k = 'lat' + str(1)
lon_k = 'lon' + str(1)
uu, vv, lon_k, lat_k, time = [], [], [], [], []
uu.append(u1)
vv.append(v1)
lat_k.append(la)
lon_k.append(lo)
time.append(date2num(startdate))
delete_id = []
for i in range(1, int(nsteps)):
# first, estimate the particle move to its new position using velocity of previous time steps
lat1 = lat_k[i - 1] + vv[i - 1] * daystep * 0.7769085
lon1 = lon_k[i - 1] + uu[i - 1] * daystep * 0.7769085 * scipy.cos(
lat_k[i - 1] / 180 * np.pi)
# find the closest model time for the new timestep
jdmat_m_num_i = time[i - 1] + daystep
time.append(jdmat_m_num_i)
index_startdate_1 = int(
round(
np.interp(jdmat_m_num_i, jdmat_m_num,
range(len(jdmat_m_num)))))
if del_index != []:
index_add = int(
np.ceil(
np.interp(index_startdate_1, del_index,
range(len(del_index)))))
index_startdate = index_add + index_startdate_1
else:
index_startdate = index_startdate_1
#find the point's index of near lat1,lon1
index_location = nearxy(lon_vel_1, lat_vel_1, lon1, lat1)[1]
# calculate the model depth
depth_model = getdepth(lat_k[i - 1], lon_k[i - 1])
#get u and v
ui = u[index_startdate, idz, index_location]
vi = v[index_startdate, idz, index_location]
vv.append(vi)
uu.append(ui)
# estimate the particle move from its new position using velocity of previous time steps
lat_k.append((lat1 + lat_k[i - 1] + vv[i] * daystep * 0.7769085) / 2.)
lon_k.append(
(lon1 + lon_k[i - 1] +
uu[i] * daystep * 0.7769085 * scipy.cos(lat_k[i] / 180 * np.pi)) /
2.)
if depth_model > 0:
delete_id.append(i)
#delete the depth is greater than 0
delete_id.reverse()
for i in delete_id:
del lat_k[i]
del lon_k[i]
del time[i]
del uu[i]
del vv[i]
if delete_id != []:
del lat_k[-1]
del lon_k[-1]
del time[-1]
del uu[-1]
del vv[-1]
return lat_k, lon_k, time, uu, vv