def _space_grid(Sm, spacing):
'''
Zero everywhere, except for the points at a certain grid interval.
'''
Ix, Iy, Iz = np.indices(Sm.shape)
return Sm * (np.fmod(Ix, spacing) == 0) * (np.fmod(Iy, spacing) == 0) * \
(np.fmod(Iz, spacing) == 0)
def compute_lscore_over_time(events, historyScores, run, outputfn):
runlen = max(np.fmod(historyScores[:, 0], Global_BINWIDTH)) + 1
myrun = run
myeventids = ["total"]
myruncounts = [1]
hidmin = myrun * Global_BINWIDTH
hidmax = hidmin + runlen
tmpi = np.where((historyScores[:, 0] >= hidmin) & (historyScores[:, 0] <= hidmax))[0]
costsarray = np.mean(historyScores[tmpi, 1:3], axis=1)
totalscores = np.cumsum(np.exp(-1 * Global_K * costsarray))
mydata = totalscores / totalscores[runlen - 1]
for event in events:
event.histories = listout_ranges(event.histRanges)
myeventids.append(event.id)
sys.stderr.write("working on event: %s\n" % (event.id))
myruncounts.append(event.numsims)
lscores = np.zeros(runlen)
hids = np.array(event.histories)
myhids = hids[np.where((hids <= hidmax) & (hids >= hidmin))]
myhis = np.fmod(hids, Global_BINWIDTH)
for i in xrange(myhis.size):
totalscore = totalscores[myhis[i]]
lscore = compute_likelihood_histories(myhids[: (i + 1)], historyScores, totalscore)
lscores[myhis[i]] = lscore
for i in xrange(max(myhis), hidmax):
totalscore = totalscores[i]
lscore = compute_likelihood_histories(myhids, historyScores, totalscore)
lscores[i] = lscore
mydata = np.vstack((mydata, lscores))
np.savetxt(
outputfn, mydata.T, delimiter="\t", header="\t".join(myeventids) + "\n" + "\t".join(map(str, myruncounts))
)
def historyids_to_indices(historyids, historyScores):
hids=np.array(historyids, dtype=int)
itr=np.fmod(hids, Global_BINWIDTH)
sim=np.round(hids/Global_BINWIDTH)
runlen=max(np.fmod(historyScores[:,0], Global_BINWIDTH))+1
newi=itr+sim*runlen
return newi.astype('int')
def test_infix(lhs, rhs):
ovl0 = no_op(lhs)
def test_np(fcn):
ovl_l = fcn(ovl0, rhs)
ovl_r = fcn(rhs, ovl0)
ovl_l, ovl_r = evaluate([ovl_l, ovl_r])
np_l = fcn(lhs, rhs)
np_r = fcn(rhs, lhs)
assert np.all(np.equal(ovl_l, np_l))
assert np.all(np.equal(ovl_r, np_r))
test_np(lambda x, y: x + y)
test_np(lambda x, y: x - y)
test_np(lambda x, y: x * y)
test_np(lambda x, y: x / y)
test_np(lambda x, y: x == y)
test_np(lambda x, y: x != y)
test_np(lambda x, y: x < y)
test_np(lambda x, y: x <= y)
test_np(lambda x, y: x > y)
test_np(lambda x, y: x >= y)
# OVL uses c-style fmod, not python style mod, so use numpy fmod function for test
# see : http://docs.scipy.org/doc/numpy/reference/generated/numpy.fmod.html
ovl_left, ovl_right = evaluate([ovl0 % rhs, rhs % ovl0])
np_left = np.fmod(lhs, rhs)
np_right = np.fmod(rhs, lhs)
assert np.all(np.equal(ovl_left, np_left))
assert np.all(np.equal(ovl_right, np_right))
ovl_neg = evaluate([-ovl0])
assert np.all(np.equal(ovl_neg, -lhs))
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 _visiting(self, step):
"""
Assignement of components values based on visiting distribution.
The way of exploring space depends on the Markov chain stepping
"""
# It it is the first part of the markov chain
# Changing all components at the same time
if step < self._x.size:
visits = np.array([self._visita() for _ in range(self._x.size)])
visits[visits > 1.e8] = 1.e8 * self._random_state.random_sample()
visits[visits < -1e8] = -1.e8 * self._random_state.random_sample()
self._x = visits + self._xbackup
a = self._x - self._lower
b = np.fmod(a, self._xrange) + self._xrange
self._x = np.fmod(b, self._xrange) + self._lower
self._x[np.fabs(self._x - self._lower) < 1.e-10] += 1.e-10
else:
# Second part of the markov chain
# Now change only one component at a time
visit = self._visita()
if visit > 1.e8:
visit = 1.e8 * self._random_state.random_sample()
elif visit < -1e8:
visit = -1.e8 * self._random_state.random_sample()
index = step - self._x.size
self._x[index] = visit + self._xbackup[index]
a = self._x[index] - self._lower[index]
b = np.fmod(
a, self._xrange[index]) + self._xrange[index]
self._x[index] = np.fmod(
b, self._xrange[index]) + self._lower[index]
if np.fabs(self._x[index] - self._lower[
index]) < 1.e-10:
self._x[index] += 1.e-10
def is_leap_year(year, gregorian=True):
"""Return True if this is a leap year in the Julian or Gregorian calendars
Arguments:
- `year` : (int) year
Keywords:
- `gregorian` : (bool, default=True) If True, use Gregorian calendar,
else use Julian calendar
Returns:
- (bool) True is this is a leap year, else False.
"""
year = np.atleast_1d(year).astype(np.int64)
x = np.fmod(year, 4)
if gregorian:
x = np.fmod(year, 4)
y = np.fmod(year, 100)
z = np.fmod(year, 400)
return _scalar_if_one(
np.logical_and(np.logical_not(x),
np.logical_or(y, np.logical_not(z))))
else:
return _scalar_if_one(x == 0)
def linearinterpolation(nstep,ndata,dt):
"""used for lienar interpolation between transportation matrices.
returns weights alpha, beta and indices of matrices.
Parameters
-------
nstep : int Number of timesteps
ndata : int Number of matrices
Returns
-------
alpha,beta : array
coefficients for interpolation
jalpha,jbeta : array
indices for interpolation
"""
t = np.zeros(nstep,dtype=np.float_)
for i in range(nstep):
t[i] = np.fmod(0 + i*dt, 1.0)
beta = np.array(nstep,dtype=np.float_)
alpha = np.array(nstep,dtype=np.float_)
w = t * ndata+0.5
beta = np.float_(np.fmod(w, 1.0))
alpha = np.float_(1.0-beta)
jalpha = np.fmod(np.floor(w)+ndata-1.0,ndata).astype(int)
jbeta = np.fmod(np.floor(w),ndata).astype(int)
return alpha,beta,jalpha,jbeta
def fundamental_arguments(t):
"""Compute the fundamental arguments (mean elements) of Sun and Moon.
`t` - TDB time in Julian centuries since J2000.0, as float or NumPy array
Outputs fundamental arguments, in radians:
a[0] = l (mean anomaly of the Moon)
a[1] = l' (mean anomaly of the Sun)
a[2] = F (mean argument of the latitude of the Moon)
a[3] = D (mean elongation of the Moon from the Sun)
a[4] = Omega (mean longitude of the Moon's ascending node);
from Simon section 3.4(b.3),
precession = 5028.8200 arcsec/cy)
"""
a = fa4 * t
a += fa3
a *= t
a += fa2
a *= t
a += fa1
a *= t
a += fa0
fmod(a, ASEC360, out=a)
a *= ASEC2RAD
if getattr(t, 'shape', ()):
return a
return a[:,0]
def mod180deg(x):
if x >= 0:
retval = fmod(x+180.0, 360.0)-180.0
else:
retval = -(fmod(-x+180.0, 360.0)-180.0)
assert -180.0 <= retval <= 180.0
return retval
def rebin_counts_2D_indexing_new(x, y, I, xo, yo, Io):
# use this one for 2D.
csx = np.empty((len(x), len(y)-1))
csx[0, :] = 0.0
csx[1:, :] = np.cumsum(I, axis=0)
xindices = np.interp(xo, x, np.arange(len(x), dtype='float'))
xindices_whole = np.floor(xindices).astype(int)
xindices_frac = np.fmod(xindices, 1.0)
# the only way an index will match the highest bin edge is for lookups at or outside the range of the
# source. In this case the fractional portion will always == 0.0, so clipping this to the bin edge below
# is safe and allows us to use the source weights unmodified
xintegral = csx[xindices_whole, :] + I[xindices_whole.clip(max=len(x)-2), :]*xindices_frac[:, None]
# rebinned over x
ix = np.diff(xintegral, axis=0)
csy = np.empty((len(xo)-1, len(y)))
csy[:, 0] = 0.0
csy[:, 1:] = np.cumsum(ix, axis=1)
yindices = np.interp(yo, y, np.arange(len(y), dtype='float'))
yindices_whole = np.floor(yindices).astype(int)
yindices_frac = np.fmod(yindices, 1.0)
yintegral = csy[:, yindices_whole] + ix[:, yindices_whole.clip(max=len(y)-2)]*yindices_frac[None, :]
# rebinned over x and y
ixy = np.diff(yintegral, axis=1)
Io += ixy
def plot_fft_results(freq, pow, cum, angles, x, y, freqi, powi, angi):
plt.figure(figsize=(10,15))
plt.subplot(5,1,1)
plt.plot(freq, pow, 'x')
plt.gca().set_xscale('log')
plt.xlabel('frequency')
plt.ylabel('power')
plt.hlines(powi, plt.xlim()[0], plt.xlim()[1], alpha=0.3)
plt.subplot(5,1,2)
plt.plot(freq, cum, 'x')
plt.gca().set_xscale('log')
plt.ylabel('cumulative probability')
plt.xlabel('frequency')
plt.vlines(freqi, 0, 1, alpha=0.3)
plt.subplot(5,1,3)
plt.plot(cum, pow**0.5, 'x')
plt.xlabel('cumulative probability')
plt.ylabel('amplitude')
plt.hlines(powi**0.5, plt.xlim()[0], plt.xlim()[1], alpha=0.3)
plt.subplot(5,1,4)
plt.plot(cum, numpy.fmod(angles+10*numpy.pi, 2*numpy.pi), 'x')
plt.xlabel('cumulative probability')
plt.ylabel('phase')
plt.hlines(numpy.fmod(angi+10*numpy.pi, 2*numpy.pi), plt.xlim()[0], plt.xlim()[1], alpha=0.3)
plt.subplot(5,1,5)
plt.plot(x, y, 'x')
plt.xlabel('time')
plt.ylabel('value')
xnew = numpy.linspace(x.min(), x.max(), 200)
ynew = powi**0.5 * numpy.cos(xnew * freqi * pi * 2 + angi)
plt.plot(xnew, ynew, '-', alpha=0.5, lw=3,
label="freq=%.5f\npow=%.3f\nang=%.3f" % (freqi, powi, angi))
plt.legend(loc='best', prop=dict(size=10))
def fix_ps1_coord_bugs(cols, file, hduname):
# FIXME: Work around PS1 bugs
ra, dec = cols['ra'], cols['dec']
if np.any(ra < 0):
ra[ra < 0] = np.fmod(np.fmod(ra[ra < 0], 360) + 360, 360)
if np.any(ra >= 360):
ra[ra >= 360] = np.fmod(np.fmod(ra[ra >= 360], 360) + 360, 360)
if np.any(np.abs(dec) > 90):
logger.warning("Encountered %d instances of dec > +/- 90 in file %s, %s HDU. Truncating to +/-90." % (sum(np.abs(dec) > 90), file, hduname))
dec[dec > 90] = 90
dec[dec < -90] = -90
cols['ra'], cols['dec'] = ra, dec
# Remove any NaN rows
if np.isnan(cols['ra'].sum()):
logger.warning("Encountered %d instances of ra == NaN in file %s, %s HDU. Removing those rows." % (sum(np.isnan(ra)), file, hduname))
keep = ~np.isnan(cols['ra'])
for name in cols: cols[name] = cols[name][keep]
if np.isnan(cols['dec'].sum()):
logger.warning("Encountered %d instances of dec == NaN in file %s, %s HDU. Removing those rows." % (sum(np.isnan(dec)), file, hduname))
keep = ~np.isnan(cols['dec'])
for name in cols: cols[name] = cols[name][keep]
def _level1_xfm_no_highpass(X, h0o, h1o, ext_mode):
"""Perform level 1 of the 3d transform discarding highpass subbands.
"""
# Check shape of input according to ext_mode. Note that shape of X is
# double original input in each direction.
if ext_mode == 4 and np.any(np.fmod(X.shape, 2) != 0):
raise ValueError('Input shape should be a multiple of 2 in each direction when self.ext_mode == 4')
elif ext_mode == 8 and np.any(np.fmod(X.shape, 4) != 0):
raise ValueError('Input shape should be a multiple of 4 in each direction when self.ext_mode == 8')
out = np.zeros_like(X)
# Loop over 2nd dimension extracting 2D slice from first and 3rd dimensions
for f in xrange(X.shape[1]):
# extract slice
y = X[:, f, :].T
out[:, f, :] = colfilter(y, h0o).T
# Loop over 3rd dimension extracting 2D slice from first and 2nd dimensions
for f in xrange(X.shape[2]):
y = colfilter(out[:, :, f].T, h0o).T
out[:, :, f] = colfilter(y, h0o)
return out
def render(self, model, params, frame):
# Scalar animation parameter, based on height and distance
d = model.edgeCenters[:,2] + 0.5 * model.edgeDistances
numpy.multiply(d, 1/self.height, d)
# Add global offset for Z scrolling over time
numpy.add(d, params.time * self.speed, d)
# Add an offset that depends on which tree we're in
numpy.add(d, numpy.choose(model.edgeTree, self.offsets), d)
# Periodic animation, stored in our color table. Linearly interpolate.
numpy.fmod(d, self.period, d)
color = numpy.empty((model.numLEDs, 3))
color[:,0] = numpy.interp(d, self.colorX, self.colorY[:,0])
color[:,1] = numpy.interp(d, self.colorX, self.colorY[:,1])
color[:,2] = numpy.interp(d, self.colorX, self.colorY[:,2])
# Random flickering noise
noise = numpy.random.rand(model.numLEDs).reshape(-1, 1)
numpy.multiply(noise, 0.25, noise)
numpy.add(noise, 0.75, noise)
numpy.multiply(color, noise, color)
numpy.add(frame, color, frame)
def test_impulse_negative(self):
""" check the transform of a negative impulse at a random place """
win_s = 256
i = int(floor(random()*win_s))
impulse = -.1
f = fft(win_s)
timegrain = fvec(win_s)
timegrain[0] = 0
timegrain[i] = impulse
fftgrain = f ( timegrain )
#self.plot_this ( fftgrain.phas )
assert_almost_equal ( fftgrain.norm, abs(impulse), decimal = 5 )
if impulse < 0:
# phase can be pi or -pi, as it is not unwrapped
#assert_almost_equal ( abs(fftgrain.phas[1:-1]) , pi, decimal = 6 )
assert_almost_equal ( fftgrain.phas[0], pi, decimal = 6)
assert_almost_equal ( np.fmod(fftgrain.phas[-1], pi), 0, decimal = 6)
else:
#assert_equal ( fftgrain.phas[1:-1] == 0, True)
assert_equal ( fftgrain.phas[0], 0)
assert_almost_equal ( np.fmod(fftgrain.phas[-1], pi), 0, decimal = 6)
# now check the resynthesis
synthgrain = f.rdo ( fftgrain )
#self.plot_this ( fftgrain.phas.T )
assert_equal ( fftgrain.phas <= pi, True)
assert_equal ( fftgrain.phas >= -pi, True)
#self.plot_this ( synthgrain - timegrain )
assert_almost_equal ( synthgrain, timegrain, decimal = 6 )
def transit_depths(self, p):
p = self.to_params(p)
dt = self.times[1] - self.times[0]
depths = np.zeros(self.times.shape)
left_bounds = self.times - dt/2.0
right_bounds = self.times + dt/2.0
left_time_since_transit = np.fmod(left_bounds - p['t0'], p['P'])
right_time_since_transit = np.fmod(right_bounds - p['t0'], p['P'])
left_in_transit = (left_time_since_transit > 0) & (left_time_since_transit < p['T'])
right_in_transit = (right_time_since_transit > 0) & (right_time_since_transit < p['T'])
depths[left_in_transit & right_in_transit] = 1.0
entries = right_in_transit & (~left_in_transit)
exits = left_in_transit & (~right_in_transit)
depths[entries] = right_time_since_transit[entries] / dt
depths[exits] = (p['T']-left_time_since_transit[exits])/dt
return depths
def visiting(self, x, step, temperature):
dim = x.size
if step < dim:
# Changing all coordinates with a new visting value
visits = np.array([self.visit_fn(
temperature) for _ in range(dim)])
upper_sample = self.rs.random_sample()
lower_sample = self.rs.random_sample()
visits[visits > self.tail_limit] = self.tail_limit * upper_sample
visits[visits < -self.tail_limit] = -self.tail_limit * lower_sample
x_visit = visits + x
a = x_visit - self.lower
b = np.fmod(a, self.b_range) + self.b_range
x_visit = np.fmod(b, self.b_range) + self.lower
x_visit[np.fabs(
x_visit - self.lower) < self.min_visit_bound] += 1.e-10
else:
# Changing only one coordinate at a time based on Markov chain step
x_visit = np.copy(x)
visit = self.visit_fn(temperature)
if visit > self.tail_limit:
visit = self.tail_limit * self.rs.random_sample()
elif visit < -self.tail_limit:
visit = -self.tail_limit * self.rs.random_sample()
index = step - dim
x_visit[index] = visit + x[index]
a = x_visit[index] - self.lower[index]
b = np.fmod(a, self.b_range[index]) + self.b_range[index]
x_visit[index] = np.fmod(b, self.b_range[
index]) + self.lower[index]
if np.fabs(x_visit[index] - self.lower[
index]) < self.min_visit_bound:
x_visit[index] += self.min_visit_bound
return x_visit
def analytic_phase_reset_old(phi, dx=0., dy=0.,
a=0., l_ccw=0.2, l_cw=-1., X=1., Y=1.):
# this is an older expression derived with several assumptions
assert(X == 1.)
assert(Y == 1.)
assert(l_cw == -1.)
r0 = iris_fixedpoint(a, l_ccw, l_cw, X, Y)
T = iris_period(a, l_ccw, l_cw, X, Y)
if r0 == None:
raise RuntimeError("No limit cycle found")
else:
quad1or2 = np.fmod(phi, 2 * math.pi) < math.pi
quad1or3 = np.fmod(phi, math.pi) < math.pi/2
du = (quad1or3 * dy + (1 - quad1or3) * dx) * (1 - 2*quad1or2)
ds = (quad1or3 * dx + (1 - quad1or3) * dy) * (
1 - 2*quad1or2*quad1or3 - 2*(1 - quad1or2)*(1 - quad1or3))
t = np.fmod(phi, math.pi/2)/(math.pi/2) * T/4
Q = 1/(l_ccw * r0) * np.exp(-l_ccw * t)
dt0 = -Q * du
dr = np.exp(-T/4) * (X * -dt0 + np.exp(t) * ds)
return (
(dt0
+ -1./(l_ccw * r0)
* 1./(1 - 1./(l_ccw * r0) * (r0/Y)**(1/l_ccw)) * dr)
/ T * 2*math.pi
)
def FindPosition(self,pos,dx,dy): """Finds which index the walker belongs to. Implements periodic boundary conditions on the walk-area Should work in 1d as well now""" indx = [-1,-1] if self.d==1: for i in xrange(len(self.x)+1): # print 'i = %d, x[i] = '%i,self.x[i],pos-self.x[i] if np.abs(pos-self.x[i])<dx/2.0: "This test must be implemented in 2D, and in self.checkpos()!" return i elif self.d==2: if pos[0]>self.x1_ or pos[0]<self.x0_: print 'this should not happen now! pos[x] = ',pos[0] pos[0] = np.fmod(pos[0],(self.X[0,-1]-self.X[0,0])+dx)+self.X[0,0] pos[0] *= ((self.X[0,-1]-self.X[0,0])+dx) if pos[0]<0 else 1 for i in xrange(len(self.X)): if np.abs(pos[0]-self.X[i,i])<dx/2.0: indx[0] = i break if pos[1]>self.y1_ or pos[1]<self.y0_: print 'this should not happen now, pos[y] = ',pos[1] pos[1] = np.fmod(pos[1],(self.Y[-1,0]-self.Y[0,0])+dy)+self.Y[0,0] pos[1] *= ((self.Y[-1,0]-self.Y[0,0])+dx) if pos[1]<0 else 1 # print pos[1] for j in xrange(len(self.Y)): if np.abs(pos[1]-self.Y[j,j])<dy/2.0: indx[1] = j break if indx[0] == -1 or indx[-1] == -1: print 'økadjs g' # print indx return indx
def MJD_to_Gregorian(mjd):
"""Convert Modified Julian Date to the Gregorian calender.
:param mjd: Modified Julian Date
:type mjd float:
:returns: date and time
:rtype: :func:`tuple` of :func:`str`
"""
tt = np.fmod(mjd,1)
hh = tt*24.
mm = np.fmod(hh,1)*60.
ss = np.fmod(mm,1)*60.
ss = "%08.5f"%(ss)
j = mjd+2400000.5
j = int(j)
j = j - 1721119
y = (4 * j - 1) / 146097
j = 4 * j - 1 - 146097 * y
d = j / 4
j = (4 * d + 3) / 1461
d = 4 * d + 3 - 1461 * j
d = (d + 4) / 4
m = (5 * d - 3) / 153
d = 5 * d - 3 - 153 * m
d = (d + 5) / 5
y = 100 * y + j
if m < 10:
m = m + 3
else:
m = m - 9
y = y + 1
return("%02d/%02d/%02d"%(d,m,y),"%02d:%02d:%s"%(hh,mm,ss))
def fold(spike_trains, period):
"""Fold `spike_trains` by `period`."""
# data = {key:[] for key in spike_trains.dtype.names}
rows = []
for i,row in spike_trains.iterrows():
period_num = int( np.ceil(row['duration'] / period) )
last_period = np.fmod(row['duration'], period)
spikes = row['spikes']
for idx in range(period_num):
lo = idx * period
hi = (idx+1) * period
sec = spikes[(spikes>=lo) & (spikes<hi)]
sec = np.fmod(sec, period)
r = row.copy()
r['spikes'] = sec
r['duration'] = period
rows.append(r)
if last_period > 0:
rows[-1]['duration'] = last_period
folded_trains = pd.DataFrame(rows)
folded_trains = folded_trains.reset_index(drop=True)
return folded_trains
def store_delta_theta(self):
"""Store relative phase vectors for each external cue around the track
This per-timestep method keeps track of the first clock-wise lap of the
circle-track trajectory, setting *first_lap* to False once the lap is
completed. At that point, the modulation traits *local_cue_intensity*
and *distal_cue_intensity* are activated, effectively switching on the
phase feedback mechanism.
During the first lap, initial clock-wise cue crossings trigger the
storage of the current reference phase-difference vector in association
with the corresponding external cue.
"""
# Set initial alpha value for trajectory on first timestep
if self._alpha0 == -1:
self._alpha0 = self.alpha
self._alpha_halfwave = float(radian(self._alpha0 - pi))
else:
# Binary flag logic for determining when the first lap has passed:
# Clockwise -> less-than radian comparisons
if not self._alpha_hw_flag:
if self._alpha_prev > self._alpha_halfwave and \
self.alpha <= self._alpha_halfwave:
self._alpha_hw_flag = True
elif self._alpha_prev > self._alpha0 and \
self.alpha <= self._alpha0:
self.first_lap = False
self.out('First lap completed at t=%.2fs'%self.t)
# Store phase reference vectors for local cues
for i in xrange(self.N_cues_local):
cue_alpha = \
np.fmod(self.local_offset + i*self.cue_spacing_local,
TWO_PI)
if self._alpha_prev > cue_alpha and \
(self.alpha <= cue_alpha or self.alpha-self._alpha_prev > pi):
if self.dtheta_local[i,0] != -99:
break
self.dtheta_local[i] = \
circle_diff_vec(self.theta, TWO_PI*self.omega*self.t)
self.cue_t_local[i] = self.t
self.out('Stored local cue #%d at t=%.2fs'%(i+1, self.t))
# Store phase reference vectors for distal cues
for i in xrange(self.N_cues_distal):
cue_alpha = \
np.fmod(self.distal_offset + i*self.cue_spacing_distal,
TWO_PI)
if self._alpha_prev > cue_alpha and \
(self.alpha <= cue_alpha or self.alpha-self._alpha_prev > pi):
if self.dtheta_distal[i,0] != -99:
break
self.dtheta_distal[i] = \
circle_diff_vec(self.theta, TWO_PI*self.omega*self.t)
self.cue_t_distal[i] = self.t
self.out('Stored distal cue #%d at t=%.2fs'%(i+1, self.t))
# Store current track alpha for next comparison
self._alpha_prev = self.alpha
def test_distributions():
# test that the distributions come out right
# XXX: test more distributions
bandit = base.Bandit({
'loss': hp_loguniform('lu', -2, 2) +
hp_qloguniform('qlu', np.log(1 + 0.01), np.log(20), 2) +
hp_quniform('qu', -4.999, 5, 1) +
hp_uniform('u', 0, 10)})
algo = base.Random(bandit)
trials = base.Trials()
exp = base.Experiment(trials, algo)
exp.catch_bandit_exceptions = False
N = 1000
exp.run(N)
assert len(trials) == N
idxs, vals = base.miscs_to_idxs_vals(trials.miscs)
print idxs.keys()
COUNTMAX = 130
COUNTMIN = 70
# -- loguniform
log_lu = np.log(vals['lu'])
assert len(log_lu) == N
assert -2 < np.min(log_lu)
assert np.max(log_lu) < 2
h = np.histogram(log_lu)[0]
print h
assert np.all(COUNTMIN < h)
assert np.all(h < COUNTMAX)
# -- quantized log uniform
qlu = vals['qlu']
assert np.all(np.fmod(qlu, 2) == 0)
assert np.min(qlu) == 2
assert np.max(qlu) == 20
bc_qlu = np.bincount(qlu)
assert bc_qlu[2] > bc_qlu[4] > bc_qlu[6] > bc_qlu[8]
# -- quantized uniform
qu = vals['qu']
assert np.min(qu) == -5
assert np.max(qu) == 5
assert np.all(np.fmod(qu, 1) == 0)
bc_qu = np.bincount(np.asarray(qu).astype('int') + 5)
assert np.all(40 < bc_qu), bc_qu # XXX: how to get the distribution flat
# with new rounding rule?
assert np.all(bc_qu < 125), bc_qu
assert np.all(bc_qu < COUNTMAX)
# -- uniform
u = vals['u']
assert np.min(u) > 0
assert np.max(u) < 10
h = np.histogram(u)[0]
print h
assert np.all(COUNTMIN < h)
assert np.all(h < COUNTMAX)
def filter_times(self, ts, tsundown):
tsmod=np.fmod(ts, 24.0)
tsmod = tsmod - np.fmod(tsundown, 24.0)
tsmod[tsmod < 0] += 24.0
return ts[tsmod < 12.0]
def sync(self):
while np.abs(np.fmod(time.time(),1)-0.25)> 0.1:
pass
while np.abs(np.fmod(time.time(),1)-0.25)< 0.1:
pass
stt = int(np.ceil(time.time()))
self._sendget('pps x%x' % stt)
print "armed at:",stt
def _rot2lamina(self,rotangle):
'''Transform an angle from the rotator system of reference into the
lamina one.'''
if self.dirRot != 'CW':
langle = np.fmod(-rotangle+self.zero,360)
else:
langle = np.fmod(rotangle-self.zero,360)
return langle
def _lamina2rot(self,langle):
'''Transform an angle from the lamina system of reference into the
rotator one.'''
if self.dirRot != 'CW':
rotangle = np.fmod(-langle+self.zero,360)
else:
rotangle = np.fmod(langle+self.zero,360)
return rotangle
def add_matrix_plot(subp, M, name):
"""Add the specified matrix pcolor"""
ax = f.add_subplot(subp)
ax.pcolor(M, cmap=cm.hot)
axis('image')
if N.fmod(N.fmod(subp, 230), 3) == 1:
ax.set_ylabel('A --> B')
ax.set_xlabel('A --> B [%s]'%name)
def shape_context(p, median_dist=None,
r_inner=1./8, r_outer=2.,
nbins_r=5, nbins_theta=12, nbins_phi=6,
outliers=None,
make2d=True,
sparse=False):
"""
Computes the shape-context log-polar histograms at each point in p -- the point cloud.
p is a Nxd matrix of points.
"""
N, d = p.shape
assert d==3, "shape_context is implemented only for three dimensions"
p_mean = np.mean(p, axis=0)
p_centered = p - p_mean
T = pca_frame(p)
R = T[0:3,0:3]
pt_nd = np.dot(p_centered, R)
#pt_nd = p_centered
# compute the coordinates : r,theta, phi
dists = ssd.pdist(pt_nd, 'euclidean')
if median_dist==None:
median_dist = np.median(dists)
dists = dists/median_dist
dists_nn = ssd.squareform(dists)
# theta_nn are in [0,2pi)
dx_nn, dy_nn, dz_nn = pt_nd.T[:,None,:]-pt_nd.T[:,:,None]
theta_nn = np.arctan2(dy_nn, dx_nn)
theta_nn = np.fmod(np.fmod(theta_nn,2*np.pi)+2*np.pi,2*np.pi)
# phi_nn are in [-pi/2, pi/2]
dist_xy_nn = np.sqrt(np.square(dx_nn) + np.square(dy_nn))
phi_nn = np.arctan2(dz_nn, dist_xy_nn)
# define histogram edges
r_edges = np.concatenate(([0], loglinspace(r_inner, r_outer, nbins_r)))
theta_edges = np.linspace(0, 2*np.pi, nbins_theta+1)
phi_edges = np.linspace(-np.pi/2, np.pi/2, nbins_phi+1)
combined_3nn = np.array([dists_nn, theta_nn, phi_nn])
# compute the bins : 4 dimensional matrix.
# r,t,p are the number of bins of radius, theta, phi
sc_nrtp = np.zeros((N, nbins_r, nbins_theta, nbins_phi))
for i in xrange(N):
hist, edges = np.histogramdd(combined_3nn[:,i,:].T, bins=[r_edges, theta_edges, phi_edges])
sc_nrtp[i,:,:,:] = hist
if make2d:
sc_nrtp = sc_nrtp.reshape(N, nbins_r*nbins_theta*nbins_phi)
if sparse: # convert to sparse representation
sc_nrtp = sc_nrtp.reshape(N, nbins_r*nbins_theta*nbins_phi)
sc_nrtp = sparse.csc_matrix(sc_nrtp)
return sc_nrtp
def avanceEtTourneEtAvance(t):
mod = np.fmod(t, 1)
if mod < 0.5:
return avance(t)
else:
return avanceEtTourne(t)
def u_v_2_wd_ws(u, v):
ws = np.sqrt(u * u + v * v)
tmp = 270.0 - np.arctan2(v, u) * 180 / np.pi
wd = np.fmod(tmp, 360.)
return wd, ws
def phase_exposure(start_time, stop_time, period, nbin=16, gtis=None):
"""Calculate the exposure on each phase of a pulse profile.
Parameters
----------
start_time, stop_time : float
Starting and stopping time (or phase if ``period==1``)
period : float
The pulse period (if 1, equivalent to phases)
Returns
-------
expo : array of floats
The normalized exposure of each bin in the pulse profile (1 is the
highest exposure, 0 the lowest)
Other parameters
----------------
nbin : int, optional, default 16
The number of bins in the profile
gtis : [[gti00, gti01], [gti10, gti11], ...], optional, default None
Good Time Intervals
"""
if gtis is None:
gtis = np.array([[start_time, stop_time]])
# Use precise floating points -------------
start_time = np.longdouble(start_time)
stop_time = np.longdouble(stop_time)
period = np.longdouble(period)
gtis = np.array(gtis, dtype=np.longdouble)
# -----------------------------------------
expo = np.zeros(nbin)
phs = np.linspace(0, 1, nbin + 1)
phs = np.array(list(zip(phs[0:-1], phs[1:])))
# Discard gtis outside [start, stop]
good = np.logical_and(gtis[:, 0] < stop_time, gtis[:, 1] > start_time)
gtis = gtis[good]
for g in gtis:
g0 = g[0]
g1 = g[1]
if g0 < start_time:
# If the start of the fold is inside a gti, start from there
g0 = start_time
if g1 > stop_time:
# If the end of the fold is inside a gti, end there
g1 = stop_time
length = g1 - g0
# How many periods inside this length?
nraw = length / period
# How many integer periods?
nper = nraw.astype(int)
# First raw exposure: the number of periods
expo += nper / nbin
# FRACTIONAL PART =================
# What remains is additional exposure for part of the profile.
start_phase = np.fmod(g0 / period, 1)
end_phase = nraw - nper + start_phase
limits = [[start_phase, end_phase]]
# start_phase is always < 1. end_phase not always. In this case...
if end_phase > 1:
limits = [[0, end_phase - 1], [start_phase, 1]]
for l in limits:
l0 = l[0]
l1 = l[1]
# Discards bins untouched by these limits
goodbins = np.logical_and(phs[:, 0] <= l1, phs[:, 1] >= l0)
idxs = np.arange(len(phs), dtype=int)[goodbins]
for i in idxs:
start = np.max([phs[i, 0], l0])
stop = np.min([phs[i, 1], l1])
w = stop - start
expo[i] += w
return expo / np.max(expo)
NumBeads = int(sys.argv[4])
ncol = naxis + (natom - 1) * 3 # We have considered costheta, phi, chi
print(str(ncol + 1) + 'th column')
#Import the data files here
file1 = "/work/tapas/linear-rotors-PIMC/PIMC-RotDOFs-Rpt10.05Angstrom-DipoleMoment" + str(
DipoleMoment
) + "Debye-beta0.05Kinv-Blocks20000-Passes200-System2HF-e0vsbeads" + str(
NumBeads) + "/results/output_instant.dof"
#Data processiong by Numpy
x1 = loadtxt(file1, unpack=True, usecols=[ncol])
if (naxis != 0):
x1 = np.fabs(np.fmod(x1, 2.0 * pi))
#pyplot calling first
fig = plt.figure()
plt.grid(True)
#X and Y labels
if (naxis != 0):
plt.xlabel('bins of ' + r'$\phi$')
fname = 'Phi'
else:
plt.xlabel('bins of ' + r'$\cos(\theta)$')
fname = 'CosTheta'
plt.ylabel('Density')
def plot_sky_binned(ra, dec, weights=None, data=None, plot_type='grid',
max_bin_area=5, clip_lo=None, clip_hi=None, verbose=False,
cmap='viridis', colorbar=True, label=None, basemap=None):
"""Show objects on the sky using a binned plot.
Bin values either show object counts per unit sky area or, if an array
of associated data values is provided, mean data values within each bin.
Objects can have associated weights.
Requires that matplotlib and basemap are installed. When plot_type is
"healpix", healpy must also be installed.
Parameters
----------
ra : array
Array of object RA values in degrees. Must have the same shape as
dec and will be flattened if necessary.
dec : array
Array of object DEC values in degrees. Must have the same shape as
ra and will be flattened if necessary.
weights : array or None
Optional of weights associated with each object. All objects are
assumed to have equal weight when this is None.
data : array or None
Optional array of scalar values associated with each object. The
resulting plot shows the mean data value per bin when data is
specified. Otherwise, the plot shows counts per unit sky area.
plot_type : str
Must be either 'grid' or 'healpix', and selects whether data in
binned in healpix or in (sin(DEC), RA).
max_bin_area : float
The bin size will be chosen automatically to be as close as
possible to this value but not exceeding it.
clip_lo : float or str
Clipping is applied to the plot data calculated as counts / area
or the mean data value per bin. See :func:`prepare_data` for
details.
clip_hi : float or str
Clipping is applied to the plot data calculated as counts / area
or the mean data value per bin. See :func:`prepare_data` for
details.
verbose : bool
Print information about the automatic bin size calculation.
cmap : colormap name or object
Matplotlib colormap to use for mapping data values to colors.
colorbar : bool
Draw a colorbar below the map when True.
label : str or None
Label to display under the colorbar. Ignored unless colorbar is True.
basemap : Basemap object or None
Use the specified basemap or create a default basemap using
:func:`init_sky` when None.
Returns
-------
basemap
The basemap used for the plot, which will match the input basemap
provided, or be a newly created basemap if None was provided.
"""
ra = np.asarray(ra).reshape(-1)
dec = np.asarray(dec).reshape(-1)
if len(ra) != len(dec):
raise ValueError('Arrays ra,dec must have same size.')
plot_types = ('grid', 'healpix',)
if plot_type not in plot_types:
raise ValueError(
'Invalid plot_type, should be one of {0}.'
.format(', '.join(plot_types)))
if data is not None and weights is None:
weights = np.ones_like(data)
if plot_type == 'grid':
# Convert the maximum pixel area to steradians.
max_bin_area = max_bin_area * (np.pi / 180.) ** 2
# Pick the number of bins in cos(DEC) and RA to use.
n_cos_dec = int(np.ceil(2 / np.sqrt(max_bin_area)))
n_ra = int(np.ceil(4 * np.pi / max_bin_area / n_cos_dec))
# Calculate the actual pixel area in sq. degrees.
bin_area = 360 ** 2 / np.pi / (n_cos_dec * n_ra)
if verbose:
print(
'Using {0} x {1} grid in cos(DEC) x RA'.format(n_cos_dec, n_ra),
'with pixel area {:.3f} sq.deg.'.format(bin_area))
# Calculate the bin edges in degrees.
ra_edges = np.linspace(-180., +180., n_ra + 1)
dec_edges = np.degrees(np.arcsin(np.linspace(-1., +1., n_cos_dec + 1)))
# Put RA values in the range [-180, 180).
ra = np.fmod(ra, 360.)
ra[ra >= 180.] -= 360.
# Histogram the input coordinates.
counts, _, _ = np.histogram2d(
dec, ra, [dec_edges, ra_edges], weights=weights)
if data is None:
grid_data = counts / bin_area
else:
sums, _, _ = np.histogram2d(
dec, ra, [dec_edges, ra_edges], weights=weights * data)
# This ratio might result in some nan (0/0) or inf (1/0) values,
# but these will be masked by prepare_data().
settings = np.seterr(all='ignore')
grid_data = sums / counts
np.seterr(**settings)
grid_data = prepare_data(
grid_data, clip_lo=clip_lo, clip_hi=clip_hi)
basemap = plot_grid_map(
grid_data, ra_edges, dec_edges, cmap, colorbar, label, basemap)
elif plot_type == 'healpix':
import healpy as hp
for n in range(1, 25):
nside = 2 ** n
bin_area = hp.nside2pixarea(nside, degrees=True)
if bin_area <= max_bin_area:
break
npix = hp.nside2npix(nside)
nest = False
if verbose:
print(
'Using healpix map with NSIDE={0}'.format(nside),
'and pixel area {:.3f} sq.deg.'.format(bin_area))
pixels = hp.ang2pix(nside, np.radians(90 - dec), np.radians(ra), nest)
counts = np.bincount(pixels, weights=weights, minlength=npix)
if data is None:
grid_data = counts / bin_area
else:
sums = np.bincount(pixels, weights=weights * data, minlength=npix)
grid_data = np.zeros_like(sums, dtype=float)
nonzero = counts > 0
grid_data[nonzero] = sums[nonzero] / counts[nonzero]
grid_data = prepare_data(grid_data, clip_lo=clip_lo, clip_hi=clip_hi)
basemap = plot_healpix_map(
grid_data, nest, cmap, colorbar, label, basemap)
return basemap
# PRESTO de-disperses at the high frequency channel so determine a
# correction to the middle of the band
if not events:
subpersumsub = fold_pfd.nsub / numsubbands
# Calculate the center of the summed subband freqs and delays
sumsubfreqs = (Num.arange(numsubbands)+0.5)*subpersumsub*fold_pfd.subdeltafreq + \
(fold_pfd.lofreq-0.5*fold_pfd.chan_wid)
# Note: In the following, we cannot use fold_pfd.hifreqdelay since that
# is based on the _barycentric_ high frequency (if the barycentric
# conversion was available). For TOAs, we need a topocentric
# delay, which is based on the topocentric frequency fold_pfd.hifreq
sumsubdelays = (
psr_utils.delay_from_DM(fold_pfd.bestdm, sumsubfreqs) -
psr_utils.delay_from_DM(fold_pfd.bestdm, fold_pfd.hifreq))
sumsubdelays_phs = Num.fmod(sumsubdelays / p_dedisp, 1.0)
# Save the "higest channel within a subband" freqs/delays for use in
# later DM/timing correction. PBD 2011/11/03
sumsubfreqs_hi = sumsubfreqs + \
fold_pfd.subdeltafreq/2.0 - fold_pfd.chan_wid/2.0
subdelays2 = psr_utils.delay_from_DM(fold_pfd.bestdm, sumsubfreqs) - \
psr_utils.delay_from_DM(fold_pfd.bestdm, sumsubfreqs_hi)
else:
fold_pfd.subfreqs = Num.asarray([0.0])
sumsubfreqs = Num.asarray([0.0])
sumsubdelays = Num.asarray([0.0])
# Read the template profile
if templatefilenm is not None:
template = psr_utils.read_profile(templatefilenm, normalize=1)
def write_r2_in(in_fname='R2.in',
survey_name=None,
r2_options=None,
num_regions_flag=1,
electrode_array=None,
startingRfile=None,
fwd_resis=None,
inv_dict=inv_defaults,
node_dict=None,
ncols=10,
reg_elems=None):
'''Write R2.in.'''
with open(in_fname, 'w') as f:
# Header information
header = "Project: {}, created using pyres on {}\n".format(\
survey_name,time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))
f.write(header)
f.write(" {} {} {} {} {} << job_type, mesh_type, flux_type, singularity_type, res_matrix \n".format(\
r2_options['job_type'],
r2_options['mesh_type'],
r2_options['flux_type'],
r2_options['singular_type'],
r2_options['res_matrix']))
f.write("\n") # blank space
# Mesh-dependent inputs
if int(r2_options['mesh_type']) == 4:
f.write("{0:10.0f} {1:10.0f} << numnp_x, numnp_y \n".format(
node_dict['xx'].shape[0], node_dict['yy'].shape[0]))
f.write("\n")
# Write x coordinates
for ival, xval in enumerate(node_dict['xx']):
f.write("{0:10.4f} ".format(xval))
if ival == len(node_dict['xx']) - 1:
f.write(" << xx \n")
elif np.fmod(ival + 1, ncols) == 0:
f.write("\n")
f.write("\n") # blank space
# Write topography
if node_dict['topog'] is None:
node_dict['topog'] = np.zeros_like(node_dict['xx'])
for ival, tval in enumerate(node_dict['topog']):
f.write("{0:10.4f} ".format(tval))
if ival == len(node_dict['topog']) - 1:
f.write(" << topog \n")
elif np.fmod(ival + 1, ncols) == 0:
f.write("\n")
f.write("\n")
# Write y (i.e., depth below topog) coordinates - positive down
for ival, yval in enumerate(node_dict['yy']):
f.write("{0:10.4f} ".format(yval))
if ival == len(node_dict['yy']) - 1:
f.write(" << yy \n")
elif np.fmod(ival + 1, ncols) == 0:
f.write("\n")
elif int(r2_options['mesh_type']) == 5:
f.write("{0:10.0f} {1:10.0f} << numnp_x, numnp_y \n".format(
node_dict['xx'].shape[0], node_dict['yy'].shape[0]))
f.write("\n")
# Write x coordinates
for ival, xval in enumerate(node_dict['xx']):
f.write("{0:10.4f} ".format(xval))
if ival == len(node_dict['xx']) - 1:
f.write(" << xx \n")
elif np.fmod(ival + 1, ncols) == 0:
f.write("\n")
f.write("\n") # blank space
# Write y (i.e., depth below topog) coordinates - positive down
for icol in xrange(node_dict['yy'].shape[1]):
for ival, irow in enumerate(xrange(node_dict['yy'].shape[0])):
f.write("{0:10.4f} ".format(node_dict['yy'][irow, icol]))
if ival == node_dict['yy'].shape[0] - 1:
f.write(" << yy for xx column = {}\n".format(icol))
elif np.fmod(ival + 1, ncols) == 0:
f.write("\n")
elif int(r2_options['mesh_type']) == 3:
f.write(" {} << mesh scale \n".format(inv_dict['mesh_scale']))
f.write("\n") # blank space
# Line 11
f.write(" {} << num_regions\n".format(num_regions_flag))
if num_regions_flag == 0 and startingRfile is not None:
if len(startingRfile) > 15:
print("Warning: filename must be 15 characters or less!")
f.write("{}\n".format(startingRfile))
f.write("\n") # blank space
else:
f.write("\n") # blank space
if num_regions_flag == 1 and reg_elems is None:
reg_elems = [[
electrode_array[0, 1], electrode_array[-1, 1], fwd_resis
]]
for iregion, reg_row in enumerate(reg_elems):
f.write(
"{0:10.0f} {1:10.0f} {2:10.2f} << elem_1, elem_2, res_value\n"
.format(*reg_row))
# Method-specific components
if r2_options['job_type'] == 1 or r2_options['job_type'] in [
'inverse', 'Inverse', 'inv', 'I', 'i'
]: # Inverse model options
f.write("\n") # blank space
if int(r2_options['mesh_type']) in [4, 5]:
f.write(
"{0:7.0f} {1:5.0f} << no. patches in x, no. patches in y\n"
.format(*inv_dict['patch_size_xy']))
if inv_dict['patch_size_xy'][0] == 0 and inv_dict[
'patch_size_xy'][1] == 0:
f.write(
"{0:7.0f} {1:5.0f} << num_param_x, num_param_y\n".
format(len(inv_dict['npxy'][0]),
len(inv_dict['npxy'][1])))
# Write mesh parameters in x
f.write("{0:7.0f} ".format(inv_dict['npxystart'][0]))
for ival, npxval in enumerate(inv_dict['npxy'][0]):
f.write("{} ".format(npxval))
if ival == len(inv_dict['npxy'][0]) - 1:
f.write(" << npxval \n")
elif np.fmod(ival + 1, ncols) == 0 and ival > 0:
f.write("\n")
f.write("\n") # blank space
# Write mesh parameters in y
f.write("{0:7.0f} ".format(inv_dict['npxystart'][1]))
for ival, npyval in enumerate(inv_dict['npxy'][1]):
f.write("{} ".format(npyval))
if ival == len(inv_dict['npxy'][1]) - 1:
f.write(" << npyval \n")
elif np.fmod(ival + 1, ncols) == 0 and ival > 0:
f.write("\n")
f.write("\n") # blank space
# Line 18
f.write(
" {0:3.0f} {1:5.2f} << inverse_type, target_decrease\n".
format(inv_dict['inverse_type'], inv_dict['target_decrease']))
f.write("\n") # blank space
if inv_dict['inverse_type'] == 3:
f.write("{} << qual_ratio\n".format(inv_dict['qual_ratio']))
f.write("\n") # blank space
f.write("{} {} << rho_min, rho_max\n".format(
inv_dict['rho_min'], inv_dict['rho_max']))
f.write("\n") # blank space
else:
# Inverse model options
# Regularization, Line 21
f.write("{0:6.0f}{1:5.0f} << data_type, reg_mode \n".format(
inv_dict['data_type'], inv_dict['reg_mode']))
f.write("\n") # blank space
if inv_dict['reg_mode'] in [0, 2]: # normal regularization
inv_type_txt = " ".join([
str(tempval) for tempval in [
inv_dict['tolerance'], inv_dict['max_iterations'],
inv_dict['error_mod'], inv_dict['alpha_aniso']
]
])
else: # 1 = background regularisation
inv_type_txt = " ".join([
str(tempval) for tempval in [
inv_dict['tolerance'], inv_dict['max_iterations'],
inv_dict['error_mod'], inv_dict['alpha_aniso'],
inv_dict['alpha_s']
]
])
# Write line 8, inverse type
f.write(
"{} << tolerance, max_iterations, error_mod, alpha_aniso, (alpha_s)\n"
.format(inv_type_txt))
f.write("\n") # blank space
# Error variance model parameters, Line 23 (offset error, relative error)
model_var_params = [
inv_dict['a_wgt'], inv_dict['b_wgt'], inv_dict['rho_min'],
inv_dict['rho_max']
]
f.write("{} {} {} {} << a_wgt, b_wgt, rho_min, rho_max\n".
format(*model_var_params))
f.write("\n") # blank space
if 'param_symbol' in inv_dict.keys():
for paramy_row in range(inv_dict['param_symbol']):
for paramx_val in paramy_row:
f.write("{} ".format(paramx_val))
f.write(" \n")
f.write(" \n")
# Bounding polyline for output region, eventually default to foreground outline, Line 25
f.write("{0:d} << number of points in polyline\n".format(
int(inv_dict['num_xy_poly'])))
if inv_dict[
'num_xy_poly'] > 0: # Write poly coordinates if at least one output polyline
for ipolyxy in inv_dict['xy_poly']:
f.write("{} {} << x_poly, y_poly\n".format(
ipolyxy[0], ipolyxy[1]))
f.write("\n") # blank space
f.write("\n") # blank space
# Write electrode information
f.write("{} << num_electrodes\n".format(electrode_array.shape[0]))
if r2_options['mesh_type'] == 3:
for elec_row in electrode_array:
f.write("{0:8.0f} {1:8.0f} << electrode number, mesh node\n".
format(*elec_row))
else:
for elec_row in electrode_array:
f.write(
"{0:8.0f} {1:8.0f} {2:8.0f} << electrode number, column, row\n"
.format(*elec_row))
f.write("\n") # blank space
def periodic(domain, idx, iaxis=[0, 1, 2]):
Nx = domain['Nx']
for i in iaxis:
idx[i] = np.fmod(idx[i], Nx[i])
idx[i][idx[i] < 0] += Nx[i]
def testTruncateModFloat(self): nums, divs = self.floatTestData() tf_result = math_ops.truncatemod(nums, divs) np_result = np.fmod(nums, divs) self.assertAllEqual(tf_result, np_result)
def testTruncateModFloat(self):
nums, divs = self.floatTestData()
with self.test_session():
tf_result = math_ops.truncatemod(nums, divs).eval()
np_result = np.fmod(nums, divs)
self.assertAllEqual(tf_result, np_result)
def column_incremental_stable_principal_component_pursuit(
c,
U,
sv,
l=None,
s=None,
rtol=1e-12,
maxiter=1000,
delta=1e-12,
ls=1.,
rho=1.,
update_basis=False,
adjust_basis_every=np.nan,
forget=1.,
max_rank=np.inf,
min_sv=0.,
orth_eps=1e-12,
orthogonalize_basis=False,
nesterovs_momentum=False,
restart_every=np.nan,
prox_ls=lambda q, r, c: prox.ind_l2ball(q, r, c),
prox_l=lambda q, th, U: prox.squ_l2_from_subspace(q, U, th),
prox_s=lambda q, ls: prox.l1(q, ls)):
"""
Column incremental online stable principal component pursuit (OnlSPCP)
performs the low-rank and sparse matrix approximation by solving
([l;s], [zls; zl; zs]) = arg min_(x,z) g_ls(z_ls) + g_l(z_l) + g_s(z_s)
s.t. [zls; zl; zs] = [I I; I O; O I] * [l; s].
Here, by default,
g_ls(z_ls) = indicator function, i.e., zero if ||c - z_ls||_2 <= delta, infinity otherwise,
g_l(z_l) = 0.5 * ||(I-U*U')*z_l||_2^2,
g_s(z_s) = ||ls.*z_s||_1
Parameters
----------
c : ndarray, shape (`m`,)
`m`-dimensional vector to be decomposed into `l` and `s` such that ||d-(l+s)||_2<=delta.
U : ndarray, shape (`m`,`r`)
`m` x `r` matrix of left singular vectors approximately spanning the subspace of low-rank components
(overwritten with the update if update_basis is True).
sv : array_like, shape ('r',)
`r`-dimensional vector of singular values
(overwritten with the update if update_basis is True).
l : array_like, shape (`m`,), optional, default None
Initial guess of `l`. If None, `c`-`s` is used.
s : array_like, shape (`m`,), optional, default None
Initial guess of `s`. If None, `s` is numpy.zeros_like(c) is used.
rtol : scalar, optional, default 1e-12
Relative convergence tolerance of `y` and `z` in ADMM, i.e., the primal and dual residuals.
maxiter : int, optional, default 1000
Maximum iterations.
delta : scalar, optional, default 1e-12
l2-ball radius used in the indicator function for the approximation error.
ls : scalar or 1d array, optional, default 1.
Weight of sparse regularizer. `ls` can be a 1d array of weights for the entries of `s`.
rho : scalar, optional, default 1.
Augmented Lagrangian parameter.
update_basis : bool, optional, default False
Update `U` and `sv` with `l` after convergence.
adjust_basis_every : int, optional, default `np.nan`
Temporalily update `U` with `l` every `adjust_basis_every` iterations in the ADMM loop. If `np.nan`, this is disabled.
forget : scalar, optional, default 1.
Forgetting parameter in updating `U`.
max_rank : int, optional, default np.inf
Maximum rank. `U.shape[1]` and `sv.shape[0]` won't be greater than `max_rank`.
min_sv : scalar, optional, default 0.
Singular values smaller than `min_sv` is neglected. `sv` >= max(`sv`)*abs(`min_sv`) if `min_sv` is negative.
orth_eps : scalar, optional, default 1e-12
Rank increases if the magnitude of `c` in the orthogonal subspace is larger than `orth_eps`.
orthogonalize_basis : bool, optional, default False
If True, perform QR decomposition to orthogonalize `U`.
nesterovs_momentum : bool, optional, default False
Nesterov acceleration.
restart_every : int, optional, default `np.nan`
Restart the Nesterov acceleration every `restart_every` iterations. If `np.nan`, this is disabled.
prox_ls : function, optional, default `spmlib.proxop.ind_l2ball`
Proximity operator as a Python function for the regularizer g_ls of `z_ls` = `l`+`s`. By default, `prox_ls` is `lambda q,r,c:spmlib.proxop.ind_l2ball(q,r,c)`, i.e., the prox. of the indicator function of l2-ball with radius 'r' and center 'c'.
prox_l : function, optional, default `spmlib.proxop.squ_l2_from_subspace`
Proximity operator as a Python function for the regularizer g_l of `z_l` = `l`. By default, `prox_l` is `lambda q,U:spmlib.proxop.squ_l2_from_subspace(q,U,th)`, i.e., the prox. of the distance function defined as 0.5*(squared l2 distance between `l` and span`U`).
prox_s : function, optional, default `spmlib.proxop.l1`
Proximity operator as a Python function for the regularizer g_s of `z_s` = `s`. By default, `prox_s` is `lambda q,ls:spmlib.proxop.l1(q,ls)`, i.e., the soft thresholding operator as the prox. of l1 norm ||ls.*z_s||_1.
Returns
-------
l : ndarray, shape (`m`,)
Low-rank component.
s : ndarray, shape (`m`,)
Sparse component
U : ndarray
Matrix of left singular vectors.
sv : ndarray
Vector of singular values.
count : int
Iteration count.
References
----------
Tomoya Sakai, Shun Ogawa, and Hiroki Kuhara
"Sequential decomposition of 3D apparent motion fields basedon low-rank and sparse approximation"
APSIPA2017 (to appear).
Example
-------
>>> from spmlib import solver as sps
>>> U, sv = np.empty([0,0]), np.empty(0) # initialize
>>> L, S = np.zeros(C.shape), np.zeros(C.shape)
>>> for j in range(n):
>>> L[:,j], S[:,j], U, sv = sps.column_incremental_stable_principal_component_pursuit(C[:,j], U, sv, ls=0.5, update_basis=True, max_rank=50, orth_eps=linalg.norm(Y[:,j])*1e-12)[:4]
"""
m = c.shape[0]
# initialize l and s
if s is None:
s = np.zeros_like(c) # np.zeros(m, dtype=c.dtype)
if l is None:
l = c.ravel() - s
if sv.size == 0:
U, sv, V = linalg.svd(np.atleast_2d(c.T).T, full_matrices=False)
return l, s, U, sv, 0
# G = lambda x: np.concatenate((x[:m]+x[m:], x[:m], x[m:]))
# x = np.concatenate((l,s))
x = np.zeros(2 * m, dtype=c.dtype)
x[:m] = l
x[m:] = s
# z = G(x)
z = np.zeros(3 * m, dtype=c.dtype)
z[:m] = x[:m] + x[m:]
z[m:2 * m] = x[:m]
z[2 * m:] = x[m:]
y = np.zeros_like(z) # np.zeros(3*m, dtype=c.dtype)
t = 1.
count = 0
Ut = U
while count < maxiter:
count += 1
if np.fmod(count, restart_every) == 0:
t = 1.
if nesterovs_momentum:
told = t
t = 0.5 * (1. + sqrt(1. + 4. * t * t))
# update x
#dx = x.copy()
q = z - y
x[:m] = (1. / 3.) * (q[:m] + 2. * q[m:2 * m] - q[2 * m:])
x[m:] = (1. / 3.) * (q[:m] - q[m:2 * m] + 2. * q[2 * m:])
#dx = x - dx
# q = G(x) + y
q[:m] = x[:m] + x[m:] + y[:m]
q[m:2 * m] = x[:m] + y[m:2 * m]
q[2 * m:] = x[m:] + y[2 * m:]
# update z
if np.fmod(count, adjust_basis_every) == 0:
Ut = column_incremental_SVD(x[:m],
U,
sv,
forget=forget,
max_rank=max_rank,
min_sv=min_sv,
orth_eps=orth_eps,
orthogonalize_basis=False)[0]
dz = z.copy()
z[:m] = prox_ls(q[:m], delta, c.ravel())
z[m:2 * m] = prox_l(q[m:2 * m], 1. / rho, Ut)
z[2 * m:] = prox_s(q[2 * m:], ls / rho)
dz = z - dz
# update y
#y = y + G(x) - z
dy = y.copy()
y[:m] += x[:m] + x[m:] - z[:m]
y[m:2 * m] += x[:m] - z[m:2 * m]
y[2 * m:] += x[m:] - z[2 * m:]
dy = y - dy
# Nesterov acceleration
if nesterovs_momentum:
z = z + ((told - 1.) / t) * dz
y = y + ((told - 1.) / t) * dy
# check convergence of primal and dual residuals
if linalg.norm(dy) < rtol * linalg.norm(y) and linalg.norm(
dz) < rtol * linalg.norm(z):
break
l = x[:m]
s = x[m:]
if update_basis:
U, sv = column_incremental_SVD(l,
U,
sv,
forget=forget,
max_rank=max_rank,
min_sv=min_sv,
orth_eps=orth_eps,
orthogonalize_basis=orthogonalize_basis)
return l, s, U, sv, count
"bitwise_or": lambda c1, c2: c1.bitwiseOR(c2), "bitwise_xor": lambda c1, c2: c1.bitwiseXOR(c2), "copysign": F.pandas_udf(lambda s1, s2: np.copysign(s1, s2), DoubleType()), "float_power": F.pandas_udf(lambda s1, s2: np.float_power(s1, s2), DoubleType()), "floor_divide": F.pandas_udf(lambda s1, s2: np.floor_divide(s1, s2), DoubleType()), "fmax": F.pandas_udf(lambda s1, s2: np.fmax(s1, s2), DoubleType()), "fmin": F.pandas_udf(lambda s1, s2: np.fmin(s1, s2), DoubleType()), "fmod": F.pandas_udf(lambda s1, s2: np.fmod(s1, s2), DoubleType()), "gcd": F.pandas_udf(lambda s1, s2: np.gcd(s1, s2), DoubleType()), "heaviside": F.pandas_udf(lambda s1, s2: np.heaviside(s1, s2), DoubleType()), "hypot": F.hypot, "lcm": F.pandas_udf(lambda s1, s2: np.lcm(s1, s2), DoubleType()), "ldexp": F.pandas_udf(lambda s1, s2: np.ldexp(s1, s2), DoubleType()), "left_shift": F.pandas_udf(lambda s1, s2: np.left_shift(s1, s2), LongType()), "logaddexp": F.pandas_udf(lambda s1, s2: np.logaddexp(s1, s2), DoubleType()), "logaddexp2":
def get_direction_matrix(self, julianTime, seasonInt, drot1, rot2, rot3):
drot1 = np.array(drot1)
rot2 = np.array(rot2)
rot3 = np.array(rot3)
# Determine the season and roll offset based on the julianTime.
rollTimeData = self.rollTimeModel.get(julianTime,
["rollOffsets", "seasons"])
rollOffset = rollTimeData[:, 0]
seasonInt = rollTimeData[:, 1]
deg2rad = np.pi / 180.0
# Calculate the Direction Cosine Matrix to transform from RA and Dec to FPA coordinates
rot1 = rm.get_parameters(
'nominalClockingAngle') + rollOffset + seasonInt * 90.0
rot1 = rot1 + drot1
# add optional offset in X'-axis rotation
rot1 = rot1 + 180
# Need to account for 180 deg rotation of field due to imaging of mirror
rot1 = np.fmod(rot1, 360)
# make small if rot1 < -360 or rot1 > 360
if (rot1.size != rot2.size) | (rot1.size != rot3.size):
rot2 = np.tile(rot2, rot1.shape)
rot3 = np.tile(rot3, rot1.shape)
rot1 = ru.make_col(rot1)
rot2 = ru.make_col(rot2)
rot3 = ru.make_col(rot3)
srac = np.sin(rot3 * deg2rad)
# sin phi 3 rotation
crac = np.cos(rot3 * deg2rad)
# cos phi
sdec = np.sin(rot2 * deg2rad)
# sin theta 2 rotation Note 2 rotation is negative of dec in right hand sense
cdec = np.cos(rot2 * deg2rad)
# cos theta
srotc = np.sin(rot1 * deg2rad)
# sin psi 1 rotation
crotc = np.cos(rot1 * deg2rad)
# cos psi
# Extract the focal plane geometry constants
geometryData = self.geomModel.get(["chipTrans", "chipOffset"])
chipTrans = np.transpose(
np.reshape(geometryData[:, 0], (3, 42), order='F').copy())
chipOffset = np.transpose(
np.reshape(geometryData[:, 1], (3, 42), order='F').copy())
# DCM for a 3-2-1 rotation, Wertz p764
DCM11 = cdec * crac
DCM12 = cdec * srac
DCM13 = -sdec
DCM21 = -crotc * srac + srotc * sdec * crac
DCM22 = crotc * crac + srotc * sdec * srac
DCM23 = srotc * cdec
DCM31 = srotc * srac + crotc * sdec * crac
DCM32 = -srotc * crac + crotc * sdec * srac
DCM33 = crotc * cdec
# Calculate DCM for each chip relative to center of FOV
nModules2 = rm.get_parameters('nModules') * 2
DCM11c = np.zeros((nModules2, 1))
DCM12c = np.zeros((nModules2, 1))
DCM13c = np.zeros((nModules2, 1))
DCM21c = np.zeros((nModules2, 1))
DCM22c = np.zeros((nModules2, 1))
DCM23c = np.zeros((nModules2, 1))
DCM31c = np.zeros((nModules2, 1))
DCM32c = np.zeros((nModules2, 1))
DCM33c = np.zeros((nModules2, 1))
# print(chipTrans)
for i in range(nModules2): # step through each chip
srac = np.sin(deg2rad * chipTrans[i, 0])
# sin phi 3 rotation
crac = np.cos(deg2rad * chipTrans[i, 0])
# cos phi
sdec = np.sin(deg2rad * chipTrans[i, 1])
# sin theta 2 rotation
cdec = np.cos(deg2rad * chipTrans[i, 1])
# cos theta
srotc = np.sin(deg2rad * (chipTrans[i, 2] + chipOffset[i, 0]))
# sin psi 1 rotation includes rotation offset
crotc = np.cos(deg2rad * (chipTrans[i, 2] + chipOffset[i, 0]))
# cos psi
# DCM for a 3-2-1 rotation, Wertz p762
DCM11c[i, 0] = cdec * crac
DCM12c[i, 0] = cdec * srac
DCM13c[i, 0] = -sdec
DCM21c[i, 0] = -crotc * srac + srotc * sdec * crac
DCM22c[i, 0] = crotc * crac + srotc * sdec * srac
DCM23c[i, 0] = srotc * cdec
DCM31c[i, 0] = srotc * srac + crotc * sdec * crac
DCM32c[i, 0] = -srotc * crac + crotc * sdec * srac
DCM33c[i, 0] = crotc * cdec
return DCM11, DCM12, DCM13, DCM21, DCM22, DCM23, DCM31, DCM32, DCM33, DCM11c, DCM12c, DCM13c, DCM21c, DCM22c, DCM23c, DCM31c, DCM32c, DCM33c, chipOffset
def spline(path_to_files, num_pl=4, korder=5, prefix='', is_day=True):
'''
The integration of the motion equations
for the fast variables by B-splines interpolation.
'''
from numpy import fmod, log10, sqrt
from scipy.interpolate import splint, splev, splrep
# set of step size in days or years
SIZE_STEP = 365.25 if is_day else 1.
# length of the motion equations for the fast variables
NTERMS = 25000
# names of files
fnames = ['q' + str(i + 1) + '.txt' for i in range(num_pl)]
# reading of planetary masses
f = open(path_to_files + 'gm.txt', 'r')
s = f.read().split()
f.close()
mu = float(s[0])
gmass = [float(s[i]) for i in range(1, num_pl + 2)]
# mass parameters
mm, am, zo = [], [], []
zm = [gmass[i] / gmass[0] for i in range(len(gmass))][1:]
for i in range(num_pl):
mm.append(1. + sum(zm[:i + 1]))
zz = [zm[0] / (mm[0] * mu)] # reduced mass
zk = [gmass[0] * mm[0]] # gravitational parameter
for i in range(1, num_pl):
zz.append(zm[i] * mm[i - 1] / (mm[i] * mu))
for i in range(1, num_pl):
zk.append(gmass[0] * mm[i] / mm[i - 1])
# reading of initial values of averaged elements
f = open(path_to_files + 'el.txt', 'r')
s = f.read().split()
f.close()
lm, xm, ym, um, vm, qm = [], [], [], [], [], []
for i in range(num_pl):
lm.append(float(s[6 * i + 0]))
xm.append(float(s[6 * i + 1]))
ym.append(float(s[6 * i + 2]))
um.append(float(s[6 * i + 3]))
vm.append(float(s[6 * i + 4]))
qm.append(float(s[6 * i + 5]))
for i in range(num_pl):
am.append(lm[i]**2 * (zz[i]**-2) / zk[i])
zo.append(sqrt(zk[i] * am[i]**-3))
# print of initial values
print '*** initial longitudes and mean motions of planets ***'
temp2 = 'l = '
for i in range(num_pl):
temp2 += str('%.16f' % qm[i]).rjust(20, ' ')
print temp2
temp2 = 'n = '
for i in range(num_pl):
temp2 += str('%.16f' % zo[i]).rjust(20, ' ')
print temp2
# input data for the integration
step = int(raw_input('> length of one step: '))
step_ch = str(step)
number = int(raw_input('> number of steps: '))
number_ch = str(int(log10(float(number * step))))
# reading series for right hands of the motion equations
num = [0 for i in range(num_pl)]
rdot = [[0 for i in range(NTERMS)] for j in range(num_pl)]
idot = [[[0 for k in range(4 * num_pl)] for i in range(NTERMS)]
for j in range(num_pl)]
for j in range(num_pl):
f = open(path_to_files + fnames[j], 'r')
s = f.read().split('\n')
f.close()
for k in range(len(s)):
if k == 0:
num[j] = int(s[0])
print fnames[j][:-4], num[j]
else:
r = s[k].split()
for i in range(len(r)):
if i == 0:
rdot[j][k] = float(r[0])
else:
idot[j][k][i - 1] = int(r[i])
# reading of averaged orbital elements (integration results)
f = open(
path_to_files + 'result_1e' + number_ch + '_' + step_ch + prefix +
'_pe.txt', 'r')
s = f.read().split('\n')
f.close()
t = []
adot = [[] for j in range(num_pl)]
for n in range(number + 1):
li, xi, yi, ui, vi = [], [], [], [], []
r = s[n + 1].split()
t.append(float(r[0]) * SIZE_STEP)
for i in range(num_pl):
li.append(float(r[5 * i + 1]))
xi.append(float(r[5 * i + 2]))
yi.append(float(r[5 * i + 3]))
ui.append(float(r[5 * i + 4]))
vi.append(float(r[5 * i + 5]))
for j in range(num_pl):
temp2 = 0
for k in range(num[j]):
temp = 1.
for i in range(num_pl):
temp *= xi[i]**idot[j][k][0+4*i]*yi[i]**idot[j][k][1+4*i]\
*ui[i]**idot[j][k][2+4*i]*vi[i]**idot[j][k][3+4*i]
temp2 = temp2 + rdot[j][k] * temp
adot[j].append(temp2)
n = n + 1
# start of the integration process
f = open(
path_to_files + 'result_1e' + number_ch + '_' + step_ch + prefix +
'_qe.txt', 'w')
temp2 = 't'
for i in range(num_pl):
temp2 += ' alpha' + str(i + 1)
f.write(temp2 + '\n')
temp2 = str(int(t[0] / SIZE_STEP)).rjust(12, ' ')
for i in range(num_pl):
temp2 += '\t' + str('%.16f' % (qm[i] * 180. / pi)).rjust(21, ' ')
temp2 += '\n'
f.write(temp2)
# find B-splines for the interpolation
tck = [splrep(t, adot[j], k=korder) for j in range(num_pl)]
# the integration from t(1) to t(i)
for i in range(1, n):
temp = 2 * i * pi
qi = [splint(t[0], t[i], tck[j]) for j in range(num_pl)]
for j in range(num_pl):
qi[j] += (qm[j] + fmod(zo[j] * (t[i] - t[0]), 2 * pi))
for j in range(num_pl):
qi[j] = fmod(qi[j] + temp, 2 * pi)
temp2 = str(int(t[i] / SIZE_STEP)).rjust(12, ' ')
for j in range(num_pl):
temp2 += '\t' + str('%.16f' % (qi[j] * 180. / pi)).rjust(21, ' ')
temp2 += '\n'
f.write(temp2)
f.close()
im_gt = np.arctan2(im_dy, im_dx)
# define colors in BGR corresponding to the directions and index
# 0 1 2 3 -1
# W/E NE/SW N/S NW/SE empty
# red white blue green black
COLORS = np.array([(0, 0, 255), (255, 255, 255), (255, 0, 0), (0, 255, 0),
(0, 0, 0)])
# flip the negative angles
im_gt = np.where(im_gt < 0, im_gt + np.pi, im_gt)
# map the angles to directions in the way that
# [0, pi/4) [pi/4, pi/2) [pi/2, 3pi/4) [3pi/4, pi)
# W/E NE/SW N/S NW/SE
im_gt = np.fmod((im_gt + np.pi / 8), np.pi)
# map angels to indices from 0 to 4
im_dir = (im_gt // (np.pi / 4)).astype(int)
# remove the pixels with 0 magnitude
im_dir = np.where((im_gm == 0), -1, im_dir)
# remove the pixels on the boarder
im_dir[:, 0] = im_dir[:, -1] = im_dir[0, :] = im_dir[-1, :] = -1
# generate foo_dir image
out_img_dir = np.where(im_gm < 1.0, -1, im_dir).astype(int)
out_img_dir = COLORS[out_img_dir]
# map the max grd to 255
def pol2cart(phi, rho):
x = rho * np.cos(phi)
y = rho * np.sin(phi)
return(x, y)
s = np.sqrt(2)*0.0196
theta = 0
phi = 0
total = 15000
curx = np.zeros((total,1))
cury = np.zeros((total,1))
xn = 0
yn = 0
for n in range(0,total):
theta = np.fmod(theta+2*pi*s,2*pi)
phi = np.fmod(phi,2*pi)+theta
x,y = pol2cart(phi,1)
xn = x+xn
yn = y+yn
curx[n] = xn
cury[n] = yn
fig = plt.figure()
ax = fig.add_subplot(111)
line = Line2D(curx, cury, linewidth=0.5)
ax.add_line(line)
ax.set_xlim(np.min(curx), np.max(curx))
ax.set_ylim(np.min(cury), np.max(cury))
plt.axis('equal')
plt.show()
def plot_sky_circles(ra_center, dec_center, field_of_view=3.2, data=None,
cmap='viridis', facecolors='skyblue', edgecolor='none',
colorbar=True, colorbar_ticks=None, label=None,
basemap=None):
"""Plot circles on an all-sky projection.
Pass the optional data array through :func:`prepare_data` to select a
subset to plot and clip the color map to specified values or percentiles.
Requires that matplotlib and basemap are installed.
Parameters
----------
ra_center : array
1D array of RA in degrees at the centers of each circle to plot.
dec_center : array
1D array of DEC in degrees at the centers of each circle to plot.
field_of_view : array
Full sky openning angle in degrees of the circles to plot. The default
is appropriate for a DESI tile.
data : array or None
1D array of data associated with each circle, used to set its facecolor.
cmap : colormap name or object
Matplotlib colormap to use for mapping data values to colors. Ignored
unless data is specified.
facecolors : matplotlib color or array of colors
Ignored when data is specified. An array must have one entry per circle
or a single value is used for all circles.
edgecolor : matplotlib color
The edge color used for all circles. Use 'none' to hide edges.
colorbar : bool
Draw a colorbar below the map when True and data is provided.
colorbar_ticks : list or None
Use the specified colorbar ticks or determine them automatically
when None.
label : str or None
Label to display under the colorbar. Ignored unless a colorbar is
displayed.
basemap : BasemapWithEllipse or None
An instance of the BasemapWithEllipse class, normally obtained by
calling :func:`init_sky`. Create a default basemap when None.
Returns
-------
basemap
The basemap used for the plot, which will match the input basemap
provided, or be a newly created basemap if None was provided.
"""
import matplotlib.pyplot as plt
import matplotlib.colors
import matplotlib.cm
ra_center = np.asarray(ra_center)
dec_center = np.asarray(dec_center)
if len(ra_center.shape) != 1:
raise ValueError('Invalid ra_center, must be a 1D array.')
if len(dec_center.shape) != 1:
raise ValueError('Invalid dec_center, must be a 1D array.')
if len(ra_center) != len(dec_center):
raise ValueError('Arrays ra_center, dec_center must have same size.')
if data is not None:
data = prepare_data(data)
# Facecolors are determined by the data, when specified.
if data.shape != ra_center.shape:
raise ValueError('Invalid data shape, must match ra_center.')
# Colors associated with masked values in data will be ignored later.
try:
# Normalize the data using its vmin, vmax attributes, if present.
norm = matplotlib.colors.Normalize(vmin=data.vmin, vmax=data.vmax)
except AttributeError:
# Otherwise use the data limits.
norm = matplotlib.colors.Normalize(vmin=data.min(), vmax=data.max())
cmapper = matplotlib.cm.ScalarMappable(norm, cmap)
facecolors = cmapper.to_rgba(data)
else:
colorbar = False
# Try to repeat a single fixed color for all circles.
try:
facecolors = np.tile(
[matplotlib.colors.colorConverter.to_rgba(facecolors)],
(len(ra_center), 1))
except ValueError:
# Assume that facecolor is already an array.
facecolors = np.asarray(facecolors)
if len(facecolors) != len(ra_center):
raise ValueError('Invalid facecolor array.')
if basemap is None:
basemap = init_sky()
if basemap.lonmin + 360 != basemap.lonmax:
raise RuntimeError('Can only handle all-sky projections for now.')
if len(ra_center) == 0:
return
# Convert field-of-view angle into dDEC, dRA.
dDEC = 0.5 * field_of_view
dRA = dDEC / np.cos(np.radians(dec_center))
# Identify circles that wrap around the map edges in RA.
edge_dist = np.fmod(ra_center - basemap.lonmin, 360)
wrapped = np.minimum(edge_dist, 360 - edge_dist) < 1.05 * dRA
# Set the number of vertices for approximating the ellipse based
# on the field of view.
n_pt = max(8, int(np.ceil(field_of_view)))
# Loop over non-wrapped circles.
for ra, dec, dra, fc in zip(ra_center[~wrapped], dec_center[~wrapped],
dRA[~wrapped], facecolors[~wrapped]):
basemap.ellipse(ra, dec, dra, dDEC, n_pt, facecolor=fc,
edgecolor=edgecolor)
if colorbar:
mappable = matplotlib.cm.ScalarMappable(norm=norm, cmap=cmap)
mappable.set_array(data)
bar = plt.colorbar(
mappable, ax=basemap.ax, orientation='horizontal',
spacing='proportional', pad=0.01, aspect=50,
ticks=colorbar_ticks)
if label:
bar.set_label(label)
return basemap
def wrap_angle_rad_inplace(angle):
Modulo = np.fmod(angle, 2 * np.pi) # positive modulo
neg_wrap, pos_wrap = Modulo < -np.pi, Modulo > np.pi
angle[neg_wrap] = Modulo[neg_wrap] + 2 * np.pi
angle[pos_wrap] = Modulo[pos_wrap] - 2 * np.pi
angle[~(neg_wrap | pos_wrap)] = Modulo[~(neg_wrap | pos_wrap)]
def makegammas(nzrad):
"""
Make "Gamma" matrices which can be used to determine first derivative
of Zernike matrices (Noll 1976).
Parameters:
nzrad: Number of Zernike radial orders to calculate Gamma matrices for
Return:
ndarray: Array with x, then y gamma matrices
"""
n = [0]
m = [0]
tt = [1]
trig = 0
for p in range(1, nzrad + 1):
for q in range(p + 1):
if (numpy.fmod(p - q, 2) == 0):
if (q > 0):
n.append(p)
m.append(q)
trig = not (trig)
tt.append(trig)
n.append(p)
m.append(q)
trig = not (trig)
tt.append(trig)
else:
n.append(p)
m.append(q)
tt.append(1)
trig = not (trig)
nzmax = len(n)
#for j in range(nzmax):
#print j+1, n[j], m[j], tt[j]
gamx = numpy.zeros((nzmax, nzmax), "float32")
gamy = numpy.zeros((nzmax, nzmax), "float32")
# Gamma x
for i in range(nzmax):
for j in range(i + 1):
# Rule a:
if (m[i] == 0 or m[j] == 0):
gamx[i, j] = numpy.sqrt(2.0) * numpy.sqrt(
float(n[i] + 1) * float(n[j] + 1))
else:
gamx[i, j] = numpy.sqrt(float(n[i] + 1) * float(n[j] + 1))
# Rule b:
if m[i] == 0:
if ((j + 1) % 2) == 1:
gamx[i, j] = 0.0
elif m[j] == 0:
if ((i + 1) % 2) == 1:
gamx[i, j] = 0.0
else:
if (((i + 1) % 2) != ((j + 1) % 2)):
gamx[i, j] = 0.0
# Rule c:
if abs(m[j] - m[i]) != 1:
gamx[i, j] = 0.0
# Rule d - all elements positive therefore already true
# Gamma y
for i in range(nzmax):
for j in range(i + 1):
# Rule a:
if (m[i] == 0 or m[j] == 0):
gamy[i, j] = numpy.sqrt(2.0) * numpy.sqrt(
float(n[i] + 1) * float(n[j] + 1))
else:
gamy[i, j] = numpy.sqrt(float(n[i] + 1) * float(n[j] + 1))
# Rule b:
if m[i] == 0:
if ((j + 1) % 2) == 0:
gamy[i, j] = 0.0
elif m[j] == 0:
if ((i + 1) % 2) == 0:
gamy[i, j] = 0.0
else:
if (((i + 1) % 2) == ((j + 1) % 2)):
gamy[i, j] = 0.0
# Rule c:
if abs(m[j] - m[i]) != 1:
gamy[i, j] = 0.0
# Rule d:
if m[i] == 0:
pass # line 1
elif m[j] == 0:
pass # line 1
elif m[j] == (m[i] + 1):
if ((i + 1) % 2) == 1:
gamy[i, j] *= -1. # line 2
elif m[j] == (m[i] - 1):
if ((i + 1) % 2) == 0:
gamy[i, j] *= -1. # line 3
else:
pass # line 4
# FITS.Write(gamx, 'gamma_x.fits')
# FITS.Write(gamy, 'gamma_y.fits')
return numpy.array([gamx, gamy])
def ConvertVnedToTrkGsVs(vn, ve, vz):
angle = 360 + np.arctan2(ve, vn) * 180 / np.pi
trk = np.fmod(angle, 360)
gs = np.sqrt(vn**2 + ve**2)
vs = -vz
return (trk, gs, vs)
def __init__(self, filename):
self.pfd_filename = filename
infile = open(filename, "rb")
# See if the .bestprof file is around
try:
self.bestprof = bestprof(filename + ".bestprof")
except IOError:
self.bestprof = 0
swapchar = '<' # this is little-endian
data = infile.read(5 * 4)
testswap = struct.unpack(swapchar + "i" * 5, data)
# This is a hack to try and test the endianness of the data.
# None of the 5 values should be a large positive number.
if (Num.fabs(Num.asarray(testswap))).max() > 100000:
swapchar = '>' # this is big-endian
(self.numdms, self.numperiods, self.numpdots, self.nsub, self.npart) = \
struct.unpack(swapchar+"i"*5, data)
(self.proflen, self.numchan, self.pstep, self.pdstep, self.dmstep, \
self.ndmfact, self.npfact) = struct.unpack(swapchar+"i"*7, infile.read(7*4))
self.filenm = infile.read(
struct.unpack(swapchar + "i", infile.read(4))[0])
self.candnm = infile.read(
struct.unpack(swapchar + "i", infile.read(4))[0]).decode("utf-8")
self.telescope = infile.read(
struct.unpack(swapchar + "i", infile.read(4))[0]).decode("utf-8")
self.pgdev = infile.read(
struct.unpack(swapchar + "i", infile.read(4))[0])
test = infile.read(16)
if not test[:8] == b"Unknown" and b':' in test:
self.rastr = test[:test.find(b'\0')]
test = infile.read(16)
self.decstr = test[:test.find(b'\0')]
else:
self.rastr = "Unknown"
self.decstr = "Unknown"
if ':' not in test:
infile.seek(-16, 1) # rewind the file before the bad read
(self.dt, self.startT) = struct.unpack(swapchar + "dd",
infile.read(2 * 8))
(self.endT, self.tepoch, self.bepoch, self.avgvoverc, self.lofreq, \
self.chan_wid, self.bestdm) = struct.unpack(swapchar+"d"*7, infile.read(7*8))
# The following "fixes" (we think) the observing frequency of the Spigot
# based on tests done by Ingrid on 0737 (comparing it to GASP)
# The same sorts of corrections should be made to WAPP data as well...
# The tepoch corrections are empirically determined timing corrections
# Note that epoch is only double precision and so the floating
# point accuracy is ~1 us!
if self.telescope == 'GBT':
if (Num.fabs(Num.fmod(self.dt, 8.192e-05) < 1e-12) and \
("spigot" in filename.lower() or "guppi" not in filename.lower()) and \
(self.tepoch < 54832.0)):
sys.stderr.write("Assuming SPIGOT data...\n")
if self.chan_wid == 800.0 / 1024: # Spigot 800 MHz mode 2
self.lofreq -= 0.5 * self.chan_wid
# original values
#if self.tepoch > 0.0: self.tepoch += 0.039334/86400.0
#if self.bestprof: self.bestprof.epochf += 0.039334/86400.0
# values measured with 1713+0747 wrt BCPM2 on 13 Sept 2007
if self.tepoch > 0.0: self.tepoch += 0.039365 / 86400.0
if self.bestprof:
self.bestprof.epochf += 0.039365 / 86400.0
elif self.chan_wid == 800.0 / 2048:
self.lofreq -= 0.5 * self.chan_wid
if self.tepoch < 53700.0: # Spigot 800 MHz mode 16 (downsampled)
if self.tepoch > 0.0: self.tepoch += 0.039352 / 86400.0
if self.bestprof:
self.bestprof.epochf += 0.039352 / 86400.0
else: # Spigot 800 MHz mode 14
# values measured with 1713+0747 wrt BCPM2 on 13 Sept 2007
if self.tepoch > 0.0: self.tepoch += 0.039365 / 86400.0
if self.bestprof:
self.bestprof.epochf += 0.039365 / 86400.0
elif self.chan_wid == 50.0 / 1024 or self.chan_wid == 50.0 / 2048: # Spigot 50 MHz modes
self.lofreq += 0.5 * self.chan_wid
# Note: the offset has _not_ been measured for the 2048-lag mode
if self.tepoch > 0.0: self.tepoch += 0.039450 / 86400.0
if self.bestprof:
self.bestprof.epochf += 0.039450 / 86400.0
(self.topo_pow, tmp) = struct.unpack(swapchar + "f" * 2,
infile.read(2 * 4))
(self.topo_p1, self.topo_p2, self.topo_p3) = struct.unpack(swapchar+"d"*3, \
infile.read(3*8))
(self.bary_pow, tmp) = struct.unpack(swapchar + "f" * 2,
infile.read(2 * 4))
(self.bary_p1, self.bary_p2, self.bary_p3) = struct.unpack(swapchar+"d"*3, \
infile.read(3*8))
(self.fold_pow, tmp) = struct.unpack(swapchar + "f" * 2,
infile.read(2 * 4))
(self.fold_p1, self.fold_p2, self.fold_p3) = struct.unpack(swapchar+"d"*3, \
infile.read(3*8))
# Save current p, pd, pdd
# NOTE: Fold values are actually frequencies!
self.curr_p1, self.curr_p2, self.curr_p3 = \
psr_utils.p_to_f(self.fold_p1, self.fold_p2, self.fold_p3)
self.pdelays_bins = Num.zeros(self.npart, dtype='d')
(self.orb_p, self.orb_e, self.orb_x, self.orb_w, self.orb_t, self.orb_pd, \
self.orb_wd) = struct.unpack(swapchar+"d"*7, infile.read(7*8))
self.dms = Num.asarray(struct.unpack(swapchar+"d"*self.numdms, \
infile.read(self.numdms*8)))
if self.numdms == 1:
self.dms = self.dms[0]
self.periods = Num.asarray(struct.unpack(swapchar+"d"*self.numperiods, \
infile.read(self.numperiods*8)))
self.pdots = Num.asarray(struct.unpack(swapchar+"d"*self.numpdots, \
infile.read(self.numpdots*8)))
self.numprofs = self.nsub * self.npart
if (swapchar == '<'): # little endian
self.profs = Num.zeros((self.npart, self.nsub, self.proflen),
dtype='d')
for ii in range(self.npart):
for jj in range(self.nsub):
self.profs[ii,
jj, :] = Num.fromfile(infile, Num.float64,
self.proflen)
else:
self.profs = Num.asarray(struct.unpack(swapchar+"d"*self.numprofs*self.proflen, \
infile.read(self.numprofs*self.proflen*8)))
self.profs = Num.reshape(self.profs,
(self.npart, self.nsub, self.proflen))
if (self.numchan == 1):
try:
idata = infodata.infodata(
self.filenm[:self.filenm.rfind(b'.')] + b".inf")
try:
if idata.waveband == "Radio":
self.bestdm = idata.DM
self.numchan = idata.numchan
except:
self.bestdm = 0.0
self.numchan = 1
except IOError:
print("Warning! Can't open the .inf file for " + filename +
"!")
self.binspersec = self.fold_p1 * self.proflen
self.chanpersub = self.numchan // self.nsub
self.subdeltafreq = self.chan_wid * self.chanpersub
self.hifreq = self.lofreq + (self.numchan - 1) * self.chan_wid
self.losubfreq = self.lofreq + self.subdeltafreq - self.chan_wid
self.subfreqs = Num.arange(self.nsub, dtype='d')*self.subdeltafreq + \
self.losubfreq
self.subdelays_bins = Num.zeros(self.nsub, dtype='d')
# Save current DM
self.currdm = 0
self.killed_subbands = []
self.killed_intervals = []
self.pts_per_fold = []
# Note: a foldstats struct is read in as a group of 7 doubles
# the correspond to, in order:
# numdata, data_avg, data_var, numprof, prof_avg, prof_var, redchi
self.stats = Num.zeros((self.npart, self.nsub, 7), dtype='d')
for ii in range(self.npart):
currentstats = self.stats[ii]
for jj in range(self.nsub):
if (swapchar == '<'): # little endian
currentstats[jj] = Num.fromfile(infile, Num.float64, 7)
else:
currentstats[jj] = Num.asarray(struct.unpack(swapchar+"d"*7, \
infile.read(7*8)))
self.pts_per_fold.append(
self.stats[ii][0][0]) # numdata from foldstats
self.start_secs = Num.add.accumulate([0] +
self.pts_per_fold[:-1]) * self.dt
self.pts_per_fold = Num.asarray(self.pts_per_fold)
self.mid_secs = self.start_secs + 0.5 * self.dt * self.pts_per_fold
if (not self.tepoch == 0.0):
self.start_topo_MJDs = self.start_secs / 86400.0 + self.tepoch
self.mid_topo_MJDs = self.mid_secs / 86400.0 + self.tepoch
if (not self.bepoch == 0.0):
self.start_bary_MJDs = self.start_secs / 86400.0 + self.bepoch
self.mid_bary_MJDs = self.mid_secs / 86400.0 + self.bepoch
self.Nfolded = Num.add.reduce(self.pts_per_fold)
self.T = self.Nfolded * self.dt
self.avgprof = (self.profs / self.proflen).sum()
self.varprof = self.calc_varprof()
# nominal number of degrees of freedom for reduced chi^2 calculation
self.DOFnom = float(self.proflen) - 1.0
# corrected number of degrees of freedom due to inter-bin correlations
self.dt_per_bin = self.curr_p1 / self.proflen / self.dt
self.DOFcor = self.DOFnom * self.DOF_corr()
infile.close()
self.barysubfreqs = None
if self.avgvoverc == 0:
if self.candnm.startswith("PSR_"):
# If this doesn't work, we should try to use the barycentering calcs
# in the presto module.
try:
psrname = self.candnm[4:]
self.polycos = polycos.polycos(psrname,
filenm=self.pfd_filename +
".polycos")
midMJD = self.tepoch + 0.5 * self.T / 86400.0
self.avgvoverc = self.polycos.get_voverc(
int(midMJD), midMJD - int(midMJD))
#sys.stderr.write("Approximate Doppler velocity (in c) is: %.4g\n"%self.avgvoverc)
# Make the Doppler correction
self.barysubfreqs = self.subfreqs * (1.0 + self.avgvoverc)
except IOError:
self.polycos = 0
if self.barysubfreqs is None:
self.barysubfreqs = self.subfreqs
def adjust_period(self, p=None, pd=None, pdd=None, interp=0):
"""
adjust_period(p=*bestp*, pd=*bestpd*, pdd=*bestpdd*):
Rotate (internally) the profiles so that they are adjusted to
the given period and period derivatives. By default,
use the 'best' values as determined by prepfold's seaqrch.
This should orient all of the profiles so that they are
almost identical to what you see in a prepfold plot which
used searching. Use FFT-based interpolation if 'interp'
is non-zero. (NOTE: It is off by default, as in prepfold!)
"""
if self.fold_pow == 1.0:
bestp = self.bary_p1
bestpd = self.bary_p2
bestpdd = self.bary_p3
else:
bestp = self.topo_p1
bestpd = self.topo_p2
bestpdd = self.topo_p3
if p is None:
p = bestp
if pd is None:
pd = bestpd
if pdd is None:
pdd = bestpdd
# Cast to single precision and back to double precision to
# emulate prepfold_plot.c, where parttimes is of type "float"
# but values are upcast to "double" during computations.
# (surprisingly, it affects the resulting profile occasionally.)
parttimes = self.start_secs.astype('float32').astype('float64')
# Get delays
f_diff, fd_diff, fdd_diff = self.freq_offsets(p, pd, pdd)
delays = psr_utils.delay_from_foffsets(f_diff, fd_diff, fdd_diff,
parttimes)
# Convert from delays in phase to delays in bins
bin_delays = Num.fmod(delays * self.proflen,
self.proflen) - self.pdelays_bins
if interp:
new_pdelays_bins = bin_delays
else:
new_pdelays_bins = Num.floor(bin_delays + 0.5)
# Rotate subintegrations
for ii in range(self.nsub):
for jj in range(self.npart):
tmp_prof = self.profs[jj, ii, :]
# Negative sign in num bins to shift because we calculated delays
# Assuming +ve is shift-to-right, psr_utils.rotate assumes +ve
# is shift-to-left
if interp:
self.profs[jj, ii] = psr_utils.fft_rotate(
tmp_prof, -new_pdelays_bins[jj])
else:
self.profs[jj,ii] = psr_utils.rotate(tmp_prof, \
-new_pdelays_bins[jj])
self.pdelays_bins += new_pdelays_bins
if interp:
# Note: Since the rotation process slightly changes the values of the
# profs, we need to re-calculate the average profile value
self.avgprof = (self.profs / self.proflen).sum()
self.sumprof = self.profs.sum(0).sum(0)
if Num.fabs((self.sumprof / self.proflen).sum() - self.avgprof) > 1.0:
print("self.avgprof is not the correct value!")
# Save current p, pd, pdd
self.curr_p1, self.curr_p2, self.curr_p3 = p, pd, pdd
def normalize_angle(angle):
"""Normalize angle to stay between -PI and PI"""
result = np.fmod(angle + np.pi, 2.0 * np.pi)
if result <= 0:
return result + np.pi
return result - np.pi
def step(self):
self.p=self.p+self.konst*np.sin(self.q)
self.q=np.fmod(self.q+self.p,dospi)
if(self.q<0):
self.q+=dospi
def constrain_theta(theta):
theta = np.fmod(theta, 2 * no_of_points)
if (theta < 0):
theta = theta + 2 * no_of_points
return theta
def em(params_init,
seqs_train,
max_iters=500,
tol=1.0E-8,
min_var_frac=0.01,
freq_ll=5,
verbose=False):
"""
Fits GPFA model parameters using expectation-maximization (EM) algorithm.
Parameters
----------
params_init : dict
GPFA model parameters at which EM algorithm is initialized
covType : {'rbf', 'tri', 'logexp'}
type of GP covariance
gamma : np.ndarray of shape (1, #latent_vars)
related to GP timescales by
'bin_width / sqrt(gamma)'
eps : np.ndarray of shape (1, #latent_vars)
GP noise variances
d : np.ndarray of shape (#units, 1)
observation mean
C : np.ndarray of shape (#units, #latent_vars)
mapping between the neuronal data space and the
latent variable space
R : np.ndarray of shape (#units, #latent_vars)
observation noise covariance
seqs_train : np.recarray
training data structure, whose n-th entry (corresponding to the n-th
experimental trial) has fields
T : int
number of bins
y : np.ndarray (yDim x T)
neural data
max_iters : int, optional
number of EM iterations to run
Default: 500
tol : float, optional
stopping criterion for EM
Default: 1e-8
min_var_frac : float, optional
fraction of overall data variance for each observed dimension to set as
the private variance floor. This is used to combat Heywood cases,
where ML parameter learning returns one or more zero private variances.
Default: 0.01
(See Martin & McDonald, Psychometrika, Dec 1975.)
freq_ll : int, optional
data likelihood is computed at every freq_ll EM iterations.
freq_ll = 1 means that data likelihood is computed at every
iteration.
Default: 5
verbose : bool, optional
specifies whether to display status messages
Default: False
Returns
-------
params_est : dict
GPFA model parameter estimates, returned by EM algorithm (same
format as params_init)
seqs_latent : np.recarray
a copy of the training data structure, augmented with the new
fields:
xsm : np.ndarray of shape (#latent_vars x #bins)
posterior mean of latent variables at each time bin
Vsm : np.ndarray of shape (#latent_vars, #latent_vars, #bins)
posterior covariance between latent variables at each
timepoint
VsmGP : np.ndarray of shape (#bins, #bins, #latent_vars)
posterior covariance over time for each latent
variable
ll : list
list of log likelihoods after each EM iteration
iter_time : list
lisf of computation times (in seconds) for each EM iteration
"""
params = params_init
t = seqs_train['T']
y_dim, x_dim = params['C'].shape
lls = []
ll_old = ll_base = ll = 0.0
iter_time = []
var_floor = min_var_frac * np.diag(np.cov(np.hstack(seqs_train['y'])))
seqs_latent = None
# Loop once for each iteration of EM algorithm
for iter_id in trange(1,
max_iters + 1,
desc='EM iteration',
disable=not verbose):
if verbose:
print()
tic = time.time()
get_ll = (np.fmod(iter_id, freq_ll) == 0) or (iter_id <= 2)
# ==== E STEP =====
if not np.isnan(ll):
ll_old = ll
seqs_latent, ll = exact_inference_with_ll(seqs_train,
params,
get_ll=get_ll)
lls.append(ll)
# ==== M STEP ====
sum_p_auto = np.zeros((x_dim, x_dim))
for seq_latent in seqs_latent:
sum_p_auto += seq_latent['Vsm'].sum(axis=2) \
+ seq_latent['xsm'].dot(seq_latent['xsm'].T)
y = np.hstack(seqs_train['y'])
xsm = np.hstack(seqs_latent['xsm'])
sum_yxtrans = y.dot(xsm.T)
sum_xall = xsm.sum(axis=1)[:, np.newaxis]
sum_yall = y.sum(axis=1)[:, np.newaxis]
# term is (xDim+1) x (xDim+1)
term = np.vstack([
np.hstack([sum_p_auto, sum_xall]),
np.hstack([sum_xall.T, t.sum().reshape((1, 1))])
])
# yDim x (xDim+1)
cd = gpfa_util.rdiv(np.hstack([sum_yxtrans, sum_yall]), term)
params['C'] = cd[:, :x_dim]
params['d'] = cd[:, -1]
# yCent must be based on the new d
# yCent = bsxfun(@minus, [seq.y], currentParams.d);
# R = (yCent * yCent' - (yCent * [seq.xsm]') * currentParams.C')
# / sum(T);
c = params['C']
d = params['d'][:, np.newaxis]
if params['notes']['RforceDiagonal']:
sum_yytrans = (y * y).sum(axis=1)[:, np.newaxis]
yd = sum_yall * d
term = ((sum_yxtrans - d.dot(sum_xall.T)) * c).sum(axis=1)
term = term[:, np.newaxis]
r = d**2 + (sum_yytrans - 2 * yd - term) / t.sum()
# Set minimum private variance
r = np.maximum(var_floor, r)
params['R'] = np.diag(r[:, 0])
else:
sum_yytrans = y.dot(y.T)
yd = sum_yall.dot(d.T)
term = (sum_yxtrans - d.dot(sum_xall.T)).dot(c.T)
r = d.dot(d.T) + (sum_yytrans - yd - yd.T - term) / t.sum()
params['R'] = (r + r.T) / 2 # ensure symmetry
if params['notes']['learnKernelParams']:
res = learn_gp_params(seqs_latent, params, verbose=verbose)
params['gamma'] = res['gamma']
t_end = time.time() - tic
iter_time.append(t_end)
# Verify that likelihood is growing monotonically
if iter_id <= 2:
ll_base = ll
elif verbose and ll < ll_old:
print('\nError: Data likelihood has decreased ',
'from {0} to {1}'.format(ll_old, ll))
elif (ll - ll_base) < (1 + tol) * (ll_old - ll_base):
break
if len(lls) < max_iters:
print('Fitting has converged after {0} EM iterations.)'.format(
len(lls)))
if np.any(np.diag(params['R']) == var_floor):
warnings.warn('Private variance floor used for one or more observed '
'dimensions in GPFA.')
return params, seqs_latent, lls, iter_time
def fmod_pos(x, p):
return np.fmod(np.fmod(x, p) + p, p)
def euler(ai, bi, select, FK4=0):
"""
NAME:
euler
PURPOSE:
Transform between Galactic, celestial, and ecliptic coordinates.
EXPLANATION:
Use the procedure ASTRO to use this routine interactively
CALLING SEQUENCE:
EULER, AI, BI, AO, BO, [ SELECT, /FK4, SELECT = ]
INPUTS:
AI - Input Longitude in DEGREES, scalar or vector. If only two
parameters are supplied, then AI and BI will be modified
to contain the output longitude and latitude.
BI - Input Latitude in DEGREES
OPTIONAL INPUT:
SELECT - Integer (1-6) specifying type of coordinate
transformation.
SELECT From To | SELECT From To
1 RA-Dec (2000) Galactic | 4 Ecliptic RA-Dec
2 Galactic RA-DEC | 5 Ecliptic Galactic
3 RA-Dec Ecliptic | 6 Galactic Ecliptic
If not supplied as a parameter or keyword, then EULER will prompt
for the value of SELECT
Celestial coordinates (RA, Dec) should be given in equinox J2000
unless the /FK4 keyword is set.
OUTPUTS:
AO - Output Longitude in DEGREES
BO - Output Latitude in DEGREES
INPUT KEYWORD:
/FK4 - If this keyword is set and non-zero, then input and output
celestial and ecliptic coordinates should be given in
equinox B1950.
/SELECT - The coordinate conversion integer (1-6) may
alternatively be specified as a keyword
NOTES:
EULER was changed in December 1998 to use J2000 coordinates as the
default, ** and may be incompatible with earlier versions***.
REVISION HISTORY:
Written W. Landsman, February 1987
Adapted from Fortran by Daryl Yentis NRL
Converted to IDL V5.0 W. Landsman September 1997
Made J2000 the default, added /FK4 keyword
W. Landsman December 1998
Add option to specify SELECT as a keyword W. Landsman March 2003
Converted to python by K. Ganga December 2007
"""
# npar = N_params()
# if npar LT 2 then begin
# print,'Syntax - EULER, AI, BI, A0, B0, [ SELECT, /FK4, SELECT= ]'
# print,' AI,BI - Input longitude,latitude in degrees'
# print,' AO,BO - Output longitude, latitude in degrees'
# print,' SELECT - Scalar (1-6) specifying transformation type'
# return
# endif
PI = np.pi
twopi = 2.0 * PI
fourpi = 4.0 * PI
deg_to_rad = 180.0 / PI
#
# ; J2000 coordinate conversions are based on the following constants
# ; (see the Hipparcos explanatory supplement).
# ; eps = 23.4392911111 # Obliquity of the ecliptic
# ; alphaG = 192.85948d Right Ascension of Galactic North Pole
# ; deltaG = 27.12825d Declination of Galactic North Pole
# ; lomega = 32.93192d Galactic longitude of celestial equator
# ; alphaE = 180.02322d Ecliptic longitude of Galactic North Pole
# ; deltaE = 29.811438523d Ecliptic latitude of Galactic North Pole
# ; Eomega = 6.3839743d Galactic longitude of ecliptic equator
#
if FK4 == 1:
equinox = '(B1950)'
psi = [
0.57595865315, 4.9261918136, 0.00000000000, 0.0000000000,
0.11129056012, 4.7005372834
]
stheta = [
0.88781538514, -0.88781538514, 0.39788119938, -0.39788119938,
0.86766174755, -0.86766174755
]
ctheta = [
0.46019978478, 0.46019978478, 0.91743694670, 0.91743694670,
0.49715499774, 0.49715499774
]
phi = [
4.9261918136, 0.57595865315, 0.0000000000, 0.00000000000,
4.7005372834, 0.11129056012
]
else:
equinox = '(J2000)'
psi = [
0.57477043300, 4.9368292465, 0.00000000000, 0.0000000000,
0.11142137093, 4.71279419371
]
stheta = [
0.88998808748, -0.88998808748, 0.39777715593, -0.39777715593,
0.86766622025, -0.86766622025
]
ctheta = [
0.45598377618, 0.45598377618, 0.91748206207, 0.91748206207,
0.49714719172, 0.49714719172
]
phi = [
4.9368292465, 0.57477043300, 0.0000000000, 0.00000000000,
4.71279419371, 0.11142137093
]
#
i = select - 1 # IDL offset
a = ai / deg_to_rad - phi[i]
b = bi / deg_to_rad
sb = np.sin(b)
cb = np.cos(b)
cbsa = cb * np.sin(a)
b = -stheta[i] * cbsa + ctheta[i] * sb
#bo = math.asin(where(b<1.0, b, 1.0)*deg_to_rad)
bo = np.arcsin(b) * deg_to_rad
#
a = np.arctan2(ctheta[i] * cbsa + stheta[i] * sb, cb * np.cos(a))
ao = np.fmod((a + psi[i] + fourpi), twopi) * deg_to_rad
return ao, bo
def optimize_param(self,y,ninit=4*24*7,rtol=0.01,\
eta=0.01,lr=0.05,nmax=100):
"""optimize_param
Use gradient descent to find optimum parameters for learning
rates alpha,beta,gamma. Wait till all of their values are
settled to a relative tolerance.
Cost is root Mean Square Error over whole time series.
Currently tries to predict day ahead.
Input:
y - series to fit
ninit - number of values to use in initial parameter fitting
rtol - relative tolerance on parameters
eta - fraction for finite-difference step
lr - learning rate
nmax - maximum number of iterations.
"""
self.fit_init_params(y)
#Super clunky way of specifiying names.
#Why did I think this was superior?
names = ['_alpha', '_beta', '_g00', '_g01', '_g10', '_g11']
pred0 = self.predict_all_days(y, ninit=ninit)
J = self.rmse(y[ninit:], pred0[ninit:])
Ni = 0
oldJ = J
J_opt = J
#loop over iterations
for i in range(nmax):
dJ_max = 0
#for each name, tweak the model's variables.
eta = eta * 0.99
for n in names:
#do finite-difference estimate of update.
p0 = self.__getattribute__(n)
self.__setattr__(n, p0 * (1 + eta))
pred = self.predict_all_days(y, ninit=ninit)
J2 = self.rmse(pred[ninit:], y[ninit:])
dJ = np.abs((J2 - J) / J)
#crop gradient to within +/- 1
p = p0 + lr * np.fmod(dJ / (eta * p0), 1)
if (p > 1):
print('param {} >1(!): {}'.format(n, p))
print('J,J2,p', J, J2, p0)
p = min(p0 + 0.5 * (1 - p0), 0.99)
elif (p < 0):
print('param {} <0(!): {}'.format(n, p))
print('J,J2,p', J, J2, p0)
p = 0.5 * p0
self.__setattr__(n, p)
J = J2
dJ_max = max(dJ, dJ_max)
Ni += 1
if (J < J_opt):
J_opt = J
self.save_opt_param()
if (dJ_max < rtol):
clear_output(wait=True)
print("Hit tolerance {} at iter {}".format(dJ, Ni))
self.plot_pred([pred, y], ['Predicted', 'Actual'])
return pred
if (Ni % 10 == 0):
clear_output(wait=True)
print("Cost, Old Cost = {},{}".format(J, oldJ))
oldJ = J.copy()
self.plot_pred([pred, y, pred - y],
['Predicted', 'Actual', 'Error'])
for n in names:
p0 = self.__getattribute__(n)
print(n, p0)
print("Failed to hit tolerance after {} iter\n".format(Ni))
print("Cost:", J, J2)
return pred
def draw_colored_pedigree(pedobj,
shading,
gfilename='pedigree',
gtitle='My_Pedigree',
gformat='jpg',
gsize='f',
gdot='1',
gorient='l',
gdirec='',
gname=0,
gfontsize=10,
garrow=1,
gtitloc='b',
gtitjust='c',
ghatch='hatch',
gprog='dot'):
"""
draw_colored_pedigree() uses the pydot bindings to the graphviz library to produce a
directed graph of your pedigree with paths of inheritance as edges and animals as
nodes. If there is more than one generation in the pedigree as determind by the "gen"
attributes of the animals in the pedigree, draw_pedigree() will use subgraphs to try
and group animals in the same generation together in the drawing. Nodes will be
colored based on the number of outgoing connections (number of offspring).
"""
from pyp_utils import string_to_table_name
_gtitle = string_to_table_name(gtitle)
if gtitloc not in ['t', 'b']:
gtitloc = 'b'
if gtitjust not in ['c', 'l', 'r']:
gtitjust = 'c'
print '[DEBUG]: Entered draw_colored_pedigree()'
# try:
import pydot
# Build a list of generations -- if we have more than on, we can use the
# "rank=same" option in dot to get nicer output.
gens = pedobj.metadata.unique_gen_list
# Set some properties for the graph.
g = pydot.Dot(label=gtitle,
labelloc=gtitloc,
labeljust=gtitjust,
graph_name=_gtitle,
type='graph',
strict=False,
suppress_disconnected=True,
simplify=True)
# Make sure that gfontsize has a valid value.
try:
gfontsize = int(gfontsize)
except:
gfontsize = 10
if gfontsize < 10:
gfontsize = 10
gfontsize = str(gfontsize)
# print 'gfontsize = %s' % (gfontsize)
g.set_page("8.5,11")
g.set_size("7.5,10")
if gorient == 'l':
g.set_orientation("landscape")
else:
g.set_orientation("portrait")
if gsize != 'l':
g.set_ratio("auto")
if gdirec == 'RL':
g.set_rankdir('RL')
elif gdirec == 'LR':
g.set_rankdir('LR')
else:
pass
g.set_center('true')
g.set_concentrate('true')
g.set_ordering('out')
if gformat not in g.formats:
gformat = 'jpg'
# If we do not have any generations, we have to draw a less-nice graph.
colormin = min(shading.values())
colormax = max(shading.values())
color_map = {}
if len(gens) <= 1:
animalCounter = 0
print '\t[DEBUG]: Only one generation'
for _m in pedobj.pedigree:
animalCounter = animalCounter + 1
if numpy.fmod(animalCounter, pedobj.kw['counter']) == 0:
print '\t[DEBUG]: Records read: %s ' % (animalCounter)
# Add a node for the current animal and set some properties.
if gname:
_node_name = _m.name
else:
_node_name = _m.animalID
_an_node = pydot.Node(_node_name)
_an_node.set_fontname('Helvetica')
# _an_node.set_fontsize('10')
_an_node.set_fontsize(gfontsize)
_an_node.set_height('0.35')
if _m.sex == 'M' or _m.sex == 'm':
_an_node.set_shape('box')
elif _m.sex == 'F' or _m.sex == 'f':
_an_node.set_shape('ellipse')
else:
pass
#print _m.userField, ghatch, ( _m.userField == ghatch )
if _m.userField == ghatch:
_an_node.set_style('filled,peripheries=2')
else:
_an_node.set_style('filled')
try:
_color = color_map[shading[_m.animalID]]
except KeyError:
_color = get_color_32(shading[_m.animalID], colormin, colormax)
color_map[shading[_m.animalID]] = _color
print '\t[DEBUG]: %s added to cache' % (_color)
_an_node.set_fillcolor(_color)
g.add_node(_an_node)
# Add the edges to the parent nodes, if any.
if _m.sireID != pedobj.kw['missing_parent']:
if gname:
if garrow:
g.add_edge(
pydot.Edge(
pedobj.pedigree[int(_m.sireID) - 1].name,
_m.name))
else:
g.add_edge(
pydot.Edge(pedobj.pedigree[int(_m.sireID) -
1].name,
_m.name,
dir='none'))
else:
if garrow:
g.add_edge(
pydot.Edge(
pedobj.pedigree[int(_m.sireID) - 1].originalID,
_m.originalID))
else:
g.add_edge(
pydot.Edge(pedobj.pedigree[int(_m.sireID) -
1].originalID,
_m.originalID,
dir='none'))
if _m.damID != pedobj.kw['missing_parent']:
if gname:
if garrow:
g.add_edge(
pydot.Edge(pedobj.pedigree[int(_m.damID) - 1].name,
_m.name))
else:
g.add_edge(
pydot.Edge(pedobj.pedigree[int(_m.damID) - 1].name,
_m.name,
dir='none'))
else:
if garrow:
g.add_edge(
pydot.Edge(
pedobj.pedigree[int(_m.damID) - 1].originalID,
_m.originalID))
else:
g.add_edge(
pydot.Edge(pedobj.pedigree[int(_m.damID) -
1].originalID,
_m.originalID,
dir='none'))
# Otherwise we can draw a nice graph.
else:
for _g in gens:
print '\t[DEBUG]: Looping over generations'
_sg_anims = []
_sg_name = 'sg%s' % (_g)
sg = pydot.Subgraph(graph_name=_sg_name,
suppress_disconnected=True,
simplify=True)
sg.set_simplify(True)
animalCounter = 0
for _m in pedobj.pedigree:
animalCounter = animalCounter + 1
if numpy.fmod(animalCounter, pedobj.kw['counter']) == 0:
print '\t[DEBUG]: Records read: %s ' % (animalCounter)
if int(_m.gen) == int(_g):
_sg_anims.append(_m.animalID)
# Add a node for the current animal and set some properties.
if gname:
_node_name = _m.name
else:
_node_name = _m.animalID
_an_node = pydot.Node(_node_name)
_an_node.set_fontname('Helvetica')
_an_node.set_fontsize(gfontsize)
_an_node.set_height('0.35')
if _m.sex == 'M' or _m.sex == 'm':
_an_node.set_shape('box')
elif _m.sex == 'F' or _m.sex == 'f':
_an_node.set_shape('ellipse')
else:
pass
if _m.userField == ghatch:
_an_node.set_style('filled,peripheries=2')
else:
_an_node.set_style('filled')
_color = get_color_32(shading[_m.animalID], colormin, colormax)
_an_node.set_fillcolor(_color)
sg.add_node(_an_node)
# Add the edges to the parent nodes, if any.
if _m.sireID != pedobj.kw['missing_parent']:
if gname:
if garrow:
sg.add_edge(
pydot.Edge(
pedobj.pedigree[int(_m.sireID) - 1].name,
_m.name))
else:
sg.add_edge(
pydot.Edge(pedobj.pedigree[int(_m.sireID) -
1].name,
_m.name,
dir='none'))
else:
if garrow:
sg.add_edge(
pydot.Edge(
pedobj.pedigree[int(_m.sireID) -
1].originalID,
_m.originalID))
else:
sg.add_edge(
pydot.Edge(pedobj.pedigree[int(_m.sireID) -
1].originalID,
_m.originalID,
dir='none'))
#if int(_m.damID) != 0:
if _m.damID != pedobj.kw['missing_parent']:
if gname:
if garrow:
sg.add_edge(
pydot.Edge(
pedobj.pedigree[int(_m.damID) - 1].name,
_m.name))
else:
sg.add_edge(
pydot.Edge(pedobj.pedigree[int(_m.damID) -
1].name,
_m.name,
dir='none'))
else:
if garrow:
sg.add_edge(
pydot.Edge(
pedobj.pedigree[int(_m.damID) -
1].originalID,
_m.originalID))
else:
sg.add_edge(
pydot.Edge(pedobj.pedigree[int(_m.damID) -
1].originalID,
_m.originalID,
dir='none'))
if len(_sg_anims) > 0:
_sg_list = ''
for _a in _sg_anims:
if len(_sg_list) == 0:
_sg_list = 'same,%s' % (_a)
else:
_sg_list = '%s,%s' % (_sg_list, _a)
sg.set_rank(_sg_list)
g.add_subgraph(sg)
# For large graphs it is nice to write out the .dot file so that it does not have to be recreated
# whenever draw_pedigree is called. Especially when I am debugging. :-)
if gdot:
dfn = '%s.dot' % (gfilename)
# try:
g.write(dfn)
# except:
# pass
# Write the graph to an output file.
outfile = '%s.%s' % (gfilename, gformat)
if gprog not in ['dot', 'neato', 'none']:
gprog = 'dot'
if gprog != 'none':
g.write(outfile, prog=gprog, format=gformat)
return 1
