def generate_smooth_gp_re_a(out_fname='data.csv', country_variation=True):
""" Generate random data based on a nested gaussian process random
effects model with age, with covariates that vary smoothly over
time (where unexplained variation in time does not interact with
unexplained variation in age)
This function generates data for all countries in all regions, and
all age groups based on the model::
Y_r,c,t = beta * X_r,c,t + f_r(t) + g_r(a) + f_c(t)
beta = [30., -.5, .1, .1, -.1, 0., 0., 0., 0., 0.]
f_r ~ GP(0, C(3.))
g_r ~ GP(0, C(2.))
f_c ~ GP(0, C(1.)) or 0 depending on country_variation flag
C(amp) = Matern(amp, scale=20., diff_degree=2)
X_r,c,t[0] = 1
X_r,c,t[1] = t - 1990.
X_r,c,t[k] ~ GP(t; 0, C(1)) for k >= 2
"""
c4 = countries_by_region()
data = col_names()
beta = [30., -.5, .1, .1, -.1, 0., 0., 0., 0., 0.]
C0 = gp.matern.euclidean(time_range, time_range, amp=1., scale=25., diff_degree=2)
C1 = gp.matern.euclidean(age_range, age_range, amp=1., scale=25., diff_degree=2)
C2 = gp.matern.euclidean(time_range, time_range, amp=.1, scale=25., diff_degree=2)
C3 = gp.matern.euclidean(time_range, time_range, amp=1., scale=25., diff_degree=2)
g = mc.rmv_normal_cov(pl.zeros_like(age_range), C1)
for r in c4:
f_r = mc.rmv_normal_cov(pl.zeros_like(time_range), C0)
g_r = mc.rmv_normal_cov(g, C1)
for c in c4[r]:
f_c = mc.rmv_normal_cov(pl.zeros_like(time_range), C2)
x_gp = {}
for k in range(2,10):
x_gp[k] = mc.rmv_normal_cov(pl.zeros_like(time_range), C3)
for j, t in enumerate(time_range):
for i, a in enumerate(age_range):
x = [1] + [j] + [x_gp[k][j] for k in range(2,10)]
y = float(pl.dot(beta, x)) + f_r[j] + g_r[i]
if country_variation:
y += f_c[j]
se = 0.
data.append([r, c, t, a, y, se] + list(x))
write(data, out_fname)
def generate_smooth_gp_re_a(out_fname='data.csv', country_variation=True):
""" Generate random data based on a nested gaussian process random
effects model with age, with covariates that vary smoothly over
time (where unexplained variation in time does not interact with
unexplained variation in age)
This function generates data for all countries in all regions, and
all age groups based on the model::
Y_r,c,t = beta * X_r,c,t + f_r(t) + g_r(a) + f_c(t)
beta = [30., -.5, .1, .1, -.1, 0., 0., 0., 0., 0.]
f_r ~ GP(0, C(3.))
g_r ~ GP(0, C(2.))
f_c ~ GP(0, C(1.)) or 0 depending on country_variation flag
C(amp) = Matern(amp, scale=20., diff_degree=2)
X_r,c,t[0] = 1
X_r,c,t[1] = t - 1990.
X_r,c,t[k] ~ GP(t; 0, C(1)) for k >= 2
"""
c4 = countries_by_region()
data = col_names()
beta = [30., -.5, .1, .1, -.1, 0., 0., 0., 0., 0.]
C0 = gp.matern.euclidean(time_range, time_range, amp=1., scale=25., diff_degree=2)
C1 = gp.matern.euclidean(age_range, age_range, amp=1., scale=25., diff_degree=2)
C2 = gp.matern.euclidean(time_range, time_range, amp=.1, scale=25., diff_degree=2)
C3 = gp.matern.euclidean(time_range, time_range, amp=1., scale=25., diff_degree=2)
g = mc.rmv_normal_cov(pl.zeros_like(age_range), C1)
for r in c4:
f_r = mc.rmv_normal_cov(pl.zeros_like(time_range), C0)
g_r = mc.rmv_normal_cov(g, C1)
for c in c4[r]:
f_c = mc.rmv_normal_cov(pl.zeros_like(time_range), C2)
x_gp = {}
for k in range(2,10):
x_gp[k] = mc.rmv_normal_cov(pl.zeros_like(time_range), C3)
for j, t in enumerate(time_range):
for i, a in enumerate(age_range):
x = [1] + [j] + [x_gp[k][j] for k in range(2,10)]
y = float(pl.dot(beta, x)) + f_r[j] + g_r[i]
if country_variation:
y += f_c[j]
se = 0.
data.append([r, c, t, a, y, se] + list(x))
write(data, out_fname)
def plotclusters(labels, imap):
outm = pl.zeros_like(imap)
for i in range(labels.max() + 1):
pixs = pl.where(labels == i)
outm[pixs] = imap[pixs].mean()
return outm
def plot(self, plot_range):
u = pb.linspace(-plot_range, plot_range, 1000)
z = pb.zeros_like(u)
for i, j in enumerate(u):
z[i] = self(j)
pb.plot(u, z)
pb.show()
def dist2(x):
R, ETA = pylab.meshgrid(r[r<fit_rcutoff], eta)
g = pylab.zeros_like(ETA)
g = evalg(x, ETA, R)
gfit = pylab.reshape(g, len(eta)*len(r[r<fit_rcutoff]))
return gfit - pylab.reshape([g[r<fit_rcutoff] for g in ghs],
len(eta)*len(r[r<fit_rcutoff]))
def linearSL(phiOld, c, nt):
"Semi-Lagrangian advection of profile in phiOld using"
"linear interpolation"
# the number of independent points
nx = len(phiOld) - 1
# add another wrap-around point for cyclic boundaries
phiOld = pl.append(phiOld, [phiOld[1]])
# new time-step arrays for phi
phi = pl.zeros_like(phiOld)
# loop over the time steps
for it in xrange(1, nt + 1):
# loop over the grid-points
for j in xrange(1, len(phi) - 1):
# The index of the point to the left of the departure point
# (wrap around if less that zero)
k = pl.floor(j - c) % nx
# the location of the departure point within interval k->k+1
beta = (-c) % 1
# Linear interpolation onto the departure point
phi[j] = (1 - beta) * phiOld[k] + beta * phiOld[k + 1]
# cyclic BCs
phi[0] = phi[-2]
phi[-1] = phi[1]
# update arrays
phiOld = phi.copy()
# return phi (without the cyclic wrap-around point)
return phi[0:len(phi) - 1]
def dS_dX(x0, PR, h_mag = .0005):
"""
calculates the Jacobian of the SLIP at the given point x0,
with PR beeing the parameters for that step
coordinates under consideration are:
y
vx
vz
only for a single step!
"""
df = []
for dim in range(len(x0)):
delta = zeros_like(x0)
delta[dim] = 1.
h = h_mag * delta
# in positive direction
resRp = sl.SLIP_step3D(x0 + h, PR)
SRp = array([resRp['y'][-1], resRp['vx'][-1], resRp['vz'][-1]])
#fhp = array(SR2 - x0)
# in negative direction
resRn = sl.SLIP_step3D(x0 - h, PR)
SRn = array([resRn['y'][-1], resRn['vx'][-1], resRn['vz'][-1]])
#fhn = array(SR2 - x0)
# derivative: difference quotient
df.append( (SRp - SRn)/(2.*h_mag) )
return vstack(df).T
def dist2(x):
R, ETA = pylab.meshgrid(r[r<fit_rcutoff], eta)
g = pylab.zeros_like(ETA)
g = evalg(x, ETA, R)
gfit = pylab.reshape(g, len(eta)*len(r[r<fit_rcutoff]))
return gfit - pylab.reshape([g[r<fit_rcutoff] for g in ghs],
len(eta)*len(r[r<fit_rcutoff]))
def dist2(x):
R, GSIGMAS = pylab.meshgrid(r[r < fit_rcutoff], gsigmas)
g = pylab.zeros_like(GSIGMAS)
g = evalg(x, GSIGMAS, R)
gfit = pylab.reshape(g, len(eta) * len(r[r < fit_rcutoff]))
return gfit - pylab.reshape([g[r < fit_rcutoff] for g in ghs],
len(gsigmas) * len(r[r < fit_rcutoff]))
def plot_count(fname, dpi=70):
# Load data
date, libxc, c, code, test, doc = np.loadtxt(fname, unpack=True)
zero = pl.zeros_like(date)
fig = pl.figure(1, figsize=(10, 5), dpi=dpi)
ax = fig.add_subplot(111)
polygon(date,
c + code + test,
c + code + test + doc,
facecolor='m',
label='Documentation')
polygon(date, c + code, c + code + test, facecolor='y', label='Tests')
polygon(date, c, c + code, facecolor='g', label='Python-code')
polygon(date, zero, c, facecolor='r', label='C-code')
polygon(date, zero, zero, facecolor='b', label='Fortran-code')
months = pl.MonthLocator()
months4 = pl.MonthLocator(interval=4)
month_year_fmt = pl.DateFormatter("%b '%y")
ax.xaxis.set_major_locator(months4)
ax.xaxis.set_minor_locator(months)
ax.xaxis.set_major_formatter(month_year_fmt)
labels = ax.get_xticklabels()
pl.setp(labels, rotation=30)
pl.axis('tight')
pl.legend(loc='upper left')
pl.title('Number of lines')
pl.savefig(fname.split('.')[0] + '.png', dpi=dpi)
def dS_dX(x0, PR, h_mag=.0005):
"""
calculates the Jacobian of the SLIP at the given point x0,
with PR beeing the parameters for that step
coordinates under consideration are:
y
vx
vz
only for a single step!
"""
df = []
for dim in range(len(x0)):
delta = zeros_like(x0)
delta[dim] = 1.
h = h_mag * delta
# in positive direction
resRp = sl.SLIP_step3D(x0 + h, PR)
SRp = array([resRp['y'][-1], resRp['vx'][-1], resRp['vz'][-1]])
#fhp = array(SR2 - x0)
# in negative direction
resRn = sl.SLIP_step3D(x0 - h, PR)
SRn = array([resRn['y'][-1], resRn['vx'][-1], resRn['vz'][-1]])
#fhn = array(SR2 - x0)
# derivative: difference quotient
df.append((SRp - SRn) / (2. * h_mag))
return vstack(df).T
def show_grey_channels(I):
K = average(I, axis=2)
for i in range(3):
J = zeros_like(I)
J[:, :, i] = K
figure(i+10)
imshow(J)
def bad_model(X):
""" Results in a matrix with shape matching X, but all rows sum to 1"""
N, T, J = X.shape
Y = pl.zeros_like(X)
for t in range(T):
Y[:,t,:] = X[:,t,:] / pl.outer(pl.array(X[:,t,:]).sum(axis=1), pl.ones(J))
return Y.view(pl.recarray)
def plot_count(fname, dpi=70):
# Load data
date, libxc, c, code, test, doc = np.loadtxt(fname, unpack=True)
zero = pl.zeros_like(date)
fig = pl.figure(1, figsize=(10, 5), dpi=dpi)
ax = fig.add_subplot(111)
polygon(date, c + code + test, c + code + test + doc,
facecolor='m', label='Documentation')
polygon(date, c + code, c + code + test,
facecolor='y', label='Tests')
polygon(date, c, c + code,
facecolor='g', label='Python-code')
polygon(date, zero, c,
facecolor='r', label='C-code')
polygon(date, zero, zero,
facecolor='b', label='Fortran-code')
months = pl.MonthLocator()
months4 = pl.MonthLocator(interval=4)
month_year_fmt = pl.DateFormatter("%b '%y")
ax.xaxis.set_major_locator(months4)
ax.xaxis.set_minor_locator(months)
ax.xaxis.set_major_formatter(month_year_fmt)
labels = ax.get_xticklabels()
pl.setp(labels, rotation=30)
pl.axis('tight')
pl.legend(loc='upper left')
pl.title('Number of lines')
pl.savefig(fname.split('.')[0] + '.png', dpi=dpi)
def plot_count(fname, dpi=70):
# Load data
date, libxc, c, code, test, doc = np.loadtxt(fname, unpack=True)
zero = pl.zeros_like(date)
fig = pl.figure(1, figsize=(10, 5), dpi=dpi)
ax = fig.add_subplot(111)
polygon(date, c + libxc + code + test, c + libxc + code + test + doc, facecolor="m", label="Documentation")
polygon(date, c + libxc + code, c + libxc + code + test, facecolor="y", label="Tests")
polygon(date, c + libxc, c + libxc + code, facecolor="g", label="Python-code")
polygon(date, c, c + libxc, facecolor="c", label="LibXC-code")
polygon(date, zero, c, facecolor="r", label="C-code")
polygon(date, zero, zero, facecolor="b", label="Fortran-code")
months = pl.MonthLocator()
months4 = pl.MonthLocator(interval=4)
month_year_fmt = pl.DateFormatter("%b '%y")
ax.xaxis.set_major_locator(months4)
ax.xaxis.set_minor_locator(months)
ax.xaxis.set_major_formatter(month_year_fmt)
labels = ax.get_xticklabels()
pl.setp(labels, rotation=30)
pl.axis("tight")
pl.legend(loc="upper left")
pl.title("Number of lines")
pl.savefig(fname.split(".")[0] + ".png", dpi=dpi)
def plot(f, x_start, x_end, x_interval=None, epsilon=0.15):
if x_interval is None:
x_interval = x_end - x_start
x = py.arange(x_start, x_end + 0.1 * x_interval, x_interval)
# y = x^2
py.plot(x, f(x), 'ko', label='$y=x^2-10$')
# y = 0
py.plot(x, py.zeros_like(x), 'ro', label='$y=0$')
# +/- epsilon
py.plot(x, epsilon * py.ones_like(x), 'r-.', label=r'$+\epsilon$')
py.plot(x, -epsilon * py.ones_like(x), 'r--', label=r'$-\epsilon$')
# x 축 이름표
# x axis label
py.xlabel('x')
# y 축 이름표
# y axis label
py.ylabel('y')
# 범례 표시
# Show legend
py.legend()
# 모눈 표시
# Indicate grid
py.grid()
return x
def dist2(x):
R, GSIGMAS = pylab.meshgrid(r[r<fit_rcutoff], gsigmas)
g = pylab.zeros_like(GSIGMAS)
g = evalg(x, GSIGMAS, R)
gfit = pylab.reshape(g, len(eta)*len(r[r<fit_rcutoff]))
return gfit - pylab.reshape([g[r<fit_rcutoff] for g in ghs],
len(gsigmas)*len(r[r<fit_rcutoff]))
def bad_model(X):
""" Results in a matrix with shape matching X, but all rows sum to 1"""
N, T, J = X.shape
Y = pl.zeros_like(X)
for t in range(T):
Y[:, t, :] = X[:, t, :] / pl.outer(
pl.array(X[:, t, :]).sum(axis=1), pl.ones(J))
return Y.view(pl.recarray)
def edge_props2(sheet, cut_node=None, trail=None, dead_end=None):
counts_file = '%s/reformated_counts%s.csv' % (DATASETS_DIR, sheet)
df = pd.read_csv(counts_file, names = ['source', 'dest', 'time'], skipinitialspace=True)
df['time'] = pd.to_datetime(df['time'])
df.sort_values(by='time', inplace=True)
times = list(df['time'])
deltas = []
starttime = times[0]
for time in times:
deltas.append((time - starttime) / pylab.timedelta64(1, 's'))
sources = list(df['source'])
dests = list(df['dest'])
counts = {}
delta_edges = defaultdict(list)
for i in xrange(len(deltas)):
delta = deltas[i]
source = sources[i]
dest = dests[i]
#edge = (source, dest)
edge = tuple(sorted((source, dest)))
if cut_node == None or cut_node in edge:
delta_edges[delta].append(edge)
counts[edge] = []
for delta in sorted(delta_edges.keys()):
for edge in counts:
count = 0
if len(counts[edge]) > 0:
count = counts[edge][- 1]
if edge in delta_edges[delta]:
count += 1
counts[edge].append(count)
step_times = pylab.arange(1, len(delta_edges.keys()) + 1, dtype=pylab.float64)
norms = pylab.zeros_like(step_times)
for edge in counts:
counts[edge] /= step_times
norms += counts[edge]
pylab.figure()
for edge in counts:
counts[edge] /= norms
if (trail == None and dead_end == None) or ((edge == trail) or (edge == dead_end)):
label = edge
if trail != None and edge == trail:
label = 'trail'
elif dead_end != None and edge == dead_end:
label = 'dead end'
pylab.plot(sorted(delta_edges.keys()), counts[edge], label=label)
pylab.legend()
pylab.xlabel('time (seconds)')
pylab.ylabel('proportion of choices on edge')
pylab.savefig('cut_edge_props%s.pdf' % sheet, format='pdf')
pylab.close()
def country_tau_c(i_c=i_c,
sigma_explained=sigma_explained,
sigma_e=sigma_e,
var_d_c=data.se[i_c]**2.):
""" country_tau_c[row] = tau[row] * 1[row.country == c]"""
country_tau_c = pl.zeros_like(data.y)
country_tau_c[i_c] = 1 / (sigma_e**2. + sigma_explained[i_c]**2. +
var_d_c)
return country_tau_c
def uatv(u):
"Transforms u to v points for the C-grid"
[nx,ny] = py.shape(u)
uatv = py.zeros_like(u)
# loop through x and y directions of u
for i in xrange(-1,nx-1):
for j in xrange(1,ny):
uatv[i,j] = 0.25*(u[i,j] + u[i+1,j] + u[i,j-1] + u[i+1,j-1])
return uatv
def int_f(a, fs=1.):
"""
A fourier-based integrator.
===========
Parameters:
===========
a : *array* (1D)
The array which should be integrated
fs : *float*
sampling time of the data
========
Returns:
========
y : *array* (1D)
The integrated array
"""
if False:
# version with "mirrored" code
xp = hstack([a, a[::-1]])
int_fluc = int_f0(xp, float(fs))[:len(a)]
baseline = mean(a) * arange(len(a)) / float(fs)
return int_fluc + baseline - int_fluc[0]
# old version
baseline = mean(a) * arange(len(a)) / float(fs)
int_fluc = int_f0(a, float(fs))
return int_fluc + baseline - int_fluc[0]
# old code - remove eventually (comment on 02/2014)
# periodify
if False:
baseline = linspace(a[0], a[-1], len(a))
a0 = a - baseline
m = a0[-1] - a0[-2]
b2 = linspace(0, -.5 * m, len(a))
baseline -= b2
a0 += b2
a2 = hstack([a0, -1. * a0[1:][::-1]]) # "smooth" periodic signal
dbase = baseline[1] - baseline[0]
t_vec = arange(len(a)) / float(fs)
baseint = baseline[0] * t_vec + .5 * dbase * t_vec ** 2
# define frequencies
T = len(a2) / float(fs)
freqs = 1. / T * arange(len(a2))
freqs[len(freqs) // 2 + 1 :] -= float(fs)
spec = fft.fft(a2)
spec_i = zeros_like(spec, dtype=complex)
spec_i[1:] = spec[1:] / (2j * pi* freqs[1:])
res_int = fft.ifft(spec_i).real[:len(a0)] + baseint
return res_int - res_int[0]
def ddyC(f, dy):
"Calculates the C-grid ddy of 2d array f at the staggered locations"
[nx, ny] = py.shape(f)
dfdy = py.zeros_like(f)
for i in xrange(-1, nx - 1):
for j in xrange(1, ny):
dfdy[i, j] = (f[i, j] - f[i, j - 1]) / dy
return dfdy
def ddxC(f, dx):
"Calculates the C-grid ddx of 2d array f at the staggered locations"
[nx, ny] = py.shape(f)
dfdx = py.zeros_like(f)
for i in xrange(-1, nx - 1):
for j in xrange(0, ny):
dfdx[i, j] = (f[i, j] - f[i - 1, j]) / dx
return dfdx
def int_f(a, fs=1.):
"""
A fourier-based integrator.
===========
Parameters:
===========
a : *array* (1D)
The array which should be integrated
fs : *float*
sampling time of the data
========
Returns:
========
y : *array* (1D)
The integrated array
"""
if False:
# version with "mirrored" code
xp = hstack([a, a[::-1]])
int_fluc = int_f0(xp, float(fs))[:len(a)]
baseline = mean(a) * arange(len(a)) / float(fs)
return int_fluc + baseline - int_fluc[0]
# old version
baseline = mean(a) * arange(len(a)) / float(fs)
int_fluc = int_f0(a, float(fs))
return int_fluc + baseline - int_fluc[0]
# old code - remove eventually (comment on 02/2014)
# periodify
if False:
baseline = linspace(a[0], a[-1], len(a))
a0 = a - baseline
m = a0[-1] - a0[-2]
b2 = linspace(0, -.5 * m, len(a))
baseline -= b2
a0 += b2
a2 = hstack([a0, -1. * a0[1:][::-1]]) # "smooth" periodic signal
dbase = baseline[1] - baseline[0]
t_vec = arange(len(a)) / float(fs)
baseint = baseline[0] * t_vec + .5 * dbase * t_vec**2
# define frequencies
T = len(a2) / float(fs)
freqs = 1. / T * arange(len(a2))
freqs[len(freqs) // 2 + 1:] -= float(fs)
spec = fft.fft(a2)
spec_i = zeros_like(spec, dtype=complex)
spec_i[1:] = spec[1:] / (2j * pi * freqs[1:])
res_int = fft.ifft(spec_i).real[:len(a0)] + baseint
return res_int - res_int[0]
def hatu(h):
"Transforms h to u points for the C-grid"
[nx, ny] = py.shape(h)
hatu = py.zeros_like(h)
# loop through x and y directions of h
for i in xrange(-1, nx - 1):
for j in xrange(0, ny):
hatu[i, j] = 0.5 * (h[i - 1, j] + h[i, j])
return hatu
def minimize_partition_measures(self):
self.Vu = pl.zeros_like(self.Kvals).reshape(-1, 1) * 1.0
self.Vo = pl.zeros_like(self.Kvals).reshape(-1, 1) * 1.0
nvals = len(self.Kvals)
for j, K in enumerate(self.Kvals):
if self.verbose:
print(f"Running with K={K} clusters")
clusters = AgglomerativeClustering(
n_clusters=K,
affinity="precomputed",
linkage="average",
connectivity=self.connectivity,
)
clusters.fit_predict(self._Affinity)
mu, MD = self.intracluster_distance(K, clusters.labels_)
dmu = self._metric.pairwise(mu[:, :self._nfeat])
dmu = pl.ma.fix_invalid(dmu, fill_value=1.0).data
if self._has_angles:
dmuang = self.haversine.pairwise(mu[:, self._nfeat:])
# dmuang =pl.ma.fix_invalid(dmuang, fill_value=pl.pi).data
dmu = pl.multiply(dmu, dmuang)
pl.fill_diagonal(dmu, pl.inf)
self.Vo[j] = K / dmu.min() # overpartition meas.
self.Vu[j] = MD.sum() / K # underpartition meas.
# We have to match Vo and Vu, we rescale Vo so that it ranges as Vu
min_max_scaler = preprocessing.MinMaxScaler(
feature_range=(self.Vu.min(), self.Vu.max()))
self.Vu = min_max_scaler.fit_transform((self.Vu)).reshape(nvals)
self.Vo = min_max_scaler.fit_transform((self.Vo)).reshape(nvals)
# minimizing the squared sum
Vsv = interp1d(self.Kvals,
pl.sqrt(self.Vu**2 + self.Vo**2).T,
kind="slinear")
Krange = pl.arange(self.Kvals.min(), self.Kvals.max())
minval = pl.argmin(Vsv(Krange) - Vsv(Krange).min())
Kopt = Krange[minval]
return Kopt
def minimize_residual_variances(self, **kwargs):
"""
Syst. residuals behave as an underpartition measures, i.e. the larger is K the lower is the residual( the more are patches the better )
stat. residuals behave as an overpartition measures, i.e. the larger is K the higher is the residuals (the lesser are the patches the worse, because you have less signal-to-noise in each patch)
"""
self.Vu = pl.zeros_like(self.Kvals).reshape(-1, 1) * 1.0
self.Vo = pl.zeros_like(self.Kvals).reshape(-1, 1) * 1.0
nvals = len(self.Kvals)
for j, K in enumerate(self.Kvals):
if self.verbose:
print(f"Running with K={K} clusters")
clusters = AgglomerativeClustering(
n_clusters=K,
affinity="precomputed",
linkage="average",
connectivity=self.connectivity,
)
clusters.fit_predict(self._Affinity)
msys, mstat = estimate_Stat_and_Sys_residuals(
clusters.labels_,
galactic_binmask=self.galactic_mask,
**kwargs)
m1 = pl.ma.masked_equal(msys[1], hp.UNSEEN).mask
m2 = pl.ma.masked_equal(mstat[1], hp.UNSEEN).mask
_, _, var_sys, var_stat = estimate_spectra(msys, mstat)
self.Vo[j], self.Vu[j] = var_stat, var_sys
# We have to match Vo and Vu, we rescale Vo so that it ranges as Vu
min_max_scaler = preprocessing.MinMaxScaler(
feature_range=(self.Vu.min(), self.Vu.max()))
self.Vu = min_max_scaler.fit_transform((self.Vu)).reshape(nvals)
self.Vo = min_max_scaler.fit_transform((self.Vo)).reshape(nvals)
Vsv = interp1d(self.Kvals,
pl.sqrt(self.Vu**2 + self.Vo**2).T,
kind="slinear")
Krange = pl.arange(self.Kvals.min(), self.Kvals.max())
minval = pl.argmin(Vsv(Krange) - Vsv(Krange).min())
Kopt = Krange[minval]
return Kopt
def hatv(h):
"Transforms h to v points for the C-grid"
[nx, ny] = py.shape(h)
hatv = py.zeros_like(h)
# loop through x and y directions of h
for i in xrange(-1, nx - 1):
hatv[i, 0] = h[i, 0]
for j in xrange(1, ny):
hatv[i, j] = 0.5 * (h[i, j - 1] + h[i, j])
return hatv
def vatu(v):
"Transforms v to u points for the C-grid"
[nx,ny] = py.shape(v)
vatu = py.zeros_like(v)
# loop through x and y directions of v
for i in xrange(-1,nx-1):
for j in xrange(0,ny-1):
vatu[i,j] = 0.25*(v[i-1,j] + v[i-1,j+1] + v[i,j] + v[i,j+1])
vatu[i,ny-1] = 0.25*(v[i-1,ny-1] + v[i,ny-1])
return vatu
def divC(u, v, dx, dy):
"Calculates the divergence of u and v for the C-grid"
[nx,ny] = py.shape(u)
divu = py.zeros_like(u)
for i in xrange(-1,nx-1):
for j in xrange(0,ny-1):
divu[i,j] = (u[i+1,j]-u[i,j])/dx + (v[i,j+1]-v[i,j])/dy
divu[i,ny-1] = (u[i+1,ny-1]-u[i,ny-1])/dx - v[i,ny-1]/dy
return divu
def ccm89(wav, a_v, r_v=3.1):
'''Get dust extincetion using CCM89 law.
Author: ZSLIN ([email protected])'''
x = 1. / wav * 1.e4 # convert Angstrom to 1./micron
nwav = len(wav)
A_lam = pl.zeros_like(wav)
for i in range(nwav):
a, b = get_a_b(x[i])
A_lam[i] = (a + b / r_v) * a_v
return A_lam
def country_param_pred_c(i=i_c,
mu=mu,
f=f[r_index_c],
g=g[r_index_c],
h=h[c_index_c],
a=a_index_c,
t=t_index_c):
""" country_param_pred_c[row] = parameter_predicted[row] * 1[row.country == c]"""
country_param_pred_c = pl.zeros_like(data.y)
country_param_pred_c[i] = mu[i] + f[t] + g[a] + h[t]
return country_param_pred_c
def ddyA(f, dy):
"Calculates the A-grid ddy of 2d array f"
[nx, ny] = py.shape(f)
dfdy = py.zeros_like(f)
for i in xrange(-1, nx - 1):
for j in xrange(1, ny - 1):
dfdy[i, j] = (f[i, j + 1] - f[i, j - 1]) / (2. * dy)
dfdy[i, 0] = 0 #(f[i,1] - f[i,0])/(2*dy)
dfdy[i, ny - 1] = 0 #(f[i,ny-1] - f[i,ny-2])/(2*dy)
return dfdy
def ddxA(f, dx):
"Calculates the A-grid ddx of 2d array f"
[nx, ny] = py.shape(f)
dfdx = py.zeros_like(f)
for i in xrange(-1, nx - 1):
for j in xrange(1, ny - 1):
dfdx[i, j] = (f[i + 1, j] - f[i - 1, j]) / (2. * dx)
dfdx[i, 0] = 0
dfdx[i, ny - 1] = 0
return dfdx
def circle(center, radius, color):
"""
plot a circle with given center and radius
Arguments
----------
center : matrix or ndarray
it should be 2x1 ndarray or matrix
radius: float
masses per mm
"""
u = pb.linspace(0, 2 * np.pi, 200)
x0 = pb.zeros_like(u)
y0 = pb.zeros_like(u)
center = pb.matrix(center)
center.shape = 2, 1
for i, j in enumerate(u):
x0[i] = radius * pb.sin(j) + center[0, 0]
y0[i] = radius * pb.cos(j) + center[1, 0]
pb.plot(x0, y0, color)
def circle(center,radius,color): """ plot a circle with given center and radius Arguments ---------- center : matrix or ndarray it should be 2x1 ndarray or matrix radius: float masses per mm """ u=pb.linspace(0,2*np.pi,200) x0=pb.zeros_like(u) y0=pb.zeros_like(u) center=pb.matrix(center) center.shape=2,1 for i,j in enumerate(u): x0[i]=radius*pb.sin(j)+center[0,0] y0[i]=radius*pb.cos(j)+center[1,0] pb.plot(x0,y0,color)
def swap_subsample(I, k=1):
for c, color in enumerate(colors):
print "%s <-- %s" %(colors[c], colors[(c+k)%3])
for i in range(3):
J = zeros_like(I)
for j in range(3):
J[:, :, j] = I[:, :, (j+k)%3]
J[:, :, i] = zoom(I[::4, ::4, (i+k)%3], 4)
figure(i+10)
title("%s channel subsampled" %colors[i])
imshow(J)
def CTCS(phiOld, c, nt, epsilon=0., alpha=1.):
"Linear advection of profile in phiOld using CTCS"
"(FTCS for 1st time step)"
"with RAW filter with coefficients epsilon and alpha"
# the number of independent points
nx = len(phiOld) - 1
# add another wrap-around point for cyclic boundaries
phiOld = pl.append(phiOld, [phiOld[1]])
# mid and new time-step arrays for phi
phi = pl.zeros_like(phiOld)
phiNew = pl.zeros_like(phiOld)
# FTCS for first time step
for i in xrange(1, nx + 1):
phi[i] = phiOld[i] - 0.5 * c * (phiOld[i + 1] - phiOld[i - 1])
# cyclic BCs
phi[0] = phi[nx]
phi[nx + 1] = phi[1]
# CTCS for remaining time steps
for it in xrange(2, nt + 1):
for i in xrange(1, nx + 1):
phiNew[i] = phiOld[i] - c * (phi[i + 1] - phi[i - 1])
# cyclic BCs
phiNew[0] = phiNew[nx]
phiNew[nx + 1] = phiNew[1]
# RAW filter
d = epsilon * (phiNew - 2 * phi + phiOld)
phi += alpha * d
phiNew += (alpha - 1.) * d
# update arrays
phiOld = phi.copy()
phi = phiNew.copy()
# return phiNew (without the cyclic wrap-around point)
return phiNew[0:nx + 1]
def sub_mean(x, N):
N = int(N)
L = len(x)
y = pl.zeros_like(x)
ii = pl.arange(-N, N + 1)
k = 1.0 / len(ii) # 1 / (2 * N + 1)
for n in range(L):
iii = pl.clip(ii + n, 0, L - 1)
s = k * sum(x[iii])
y[n] = x[n] - s
print n, x[n], iii[0], iii[-1], s
return y
def new_bad_model(F):
""" Results in a matrix with shape matching X, but all rows sum to 1"""
N, T, J = F.shape
pi = pl.zeros_like(F)
for t in range(T):
u = F[:,t,:].var(axis=0)
u /= pl.sqrt(pl.dot(u,u))
F_t_par = pl.dot(pl.atleast_2d(pl.dot(F[:,t,:], u)).T, pl.atleast_2d(u))
F_t_perp = F[:,t,:] - F_t_par
for n in range(N):
alpha = (1 - F_t_perp[n].sum()) / F_t_par[n].sum()
pi[n,t,:] = F_t_perp[n,:] + alpha*F_t_par[n,:]
return pi
def amplitude(freq, m1, m2, distance=1):
solar_mass = 1.98892e30
mpc = mega * parsec
eta = m1 * m2 / (m1 + m2)**2
M = (m1 + m2)
mu = M * eta
amp_fac = (2 * G * solar_mass) / (c**2 * distance * mpc) * \
(5. * mu / 96 )**(1./2) * \
(M / math.pi**2)**(1./3) * \
(G * solar_mass / c**3)**(-1./6)
fi = freq < isco(m1, m2)
amp = pylab.zeros_like(freq)
amp[fi] = freq[fi]**(-7. / 6) * amp_fac
return amp
def divA(u, v, dx, dy):
"Calculates the divergence of u and v for the A-grid"
[nx, ny] = py.shape(u)
divu = py.zeros_like(u)
for i in xrange(-1, nx - 1):
for j in xrange(1, ny - 1):
divu[i,j] = (u[i+1,j] - u[i-1,j])/(2.*dx) \
+ (v[i,j+1] - v[i,j-1])/(2.*dy)
divu[i,0] = (u[i+1,0] - u[i,0])/(2.*dx) \
+ (v[i,1] + v[i,0])/(2*dy)
divu[i,ny-1] = (u[i+1,ny-1] - u[i-1,ny-1])/(2.*dx) \
- (v[i,ny-1] + v[i,ny-2])/(2*dy)
return divu
def new_bad_model(F):
""" Results in a matrix with shape matching X, but all rows sum to 1"""
N, T, J = F.shape
pi = pl.zeros_like(F)
for t in range(T):
u = F[:, t, :].var(axis=0)
u /= pl.sqrt(pl.dot(u, u))
F_t_par = pl.dot(
pl.atleast_2d(pl.dot(F[:, t, :], u)).T, pl.atleast_2d(u))
F_t_perp = F[:, t, :] - F_t_par
for n in range(N):
alpha = (1 - F_t_perp[n].sum()) / F_t_par[n].sum()
pi[n, t, :] = F_t_perp[n, :] + alpha * F_t_par[n, :]
return pi
def FTCS(phiOld, k, nt):
"Diffusion of profile in phiOld using FTCS using non-dimensional"
"diffusion coefficient, k"
# new time-step array for phi
phi = pl.zeros_like(phiOld)
# FTCS
for it in xrange(nt):
for i in xrange(1,len(phi)-1):
phi[i] = phiOld[i] \
+ k*(phiOld[i+1] - 2*phiOld[i] + phiOld[i-1])
# update arrays
phiOld = phi.copy()
return phi
def int_f0(x, fs=1.):
"""
returns the 'basic' fourier integration of a signal
"""
# define frequencies
T = len(x) / float(fs)
freqs = 1. / T * arange(len(x))
freqs[len(freqs) // 2 + 1:] -= float(fs)
spec = fft.fft(x)
spec_i = zeros_like(spec, dtype=complex)
# exclude frequency 0 - it cannot be integrated
spec_i[1:] = spec[1:] / (2j * pi* freqs[1:])
if mod(len(x), 2) == 0:
spec_i[len(x) // 2] = 0.
sig_d = fft.ifft(spec_i)
return sig_d.real
def rates(S=data_sample,
Xa=Xa, Xb=Xb,
alpha=alpha, beta=beta, gamma=gamma,
bounds_func=vars['bounds_func'],
age_indices=ai,
age_weights=aw):
# calculate study-specific rate function
shifts = pl.exp(pl.dot(Xa[S], alpha) + pl.dot(Xb[S], pl.atleast_1d(beta)))
exp_gamma = pl.exp(gamma)
mu = pl.zeros_like(shifts)
for i,s in enumerate(S):
mu[i] = pl.dot(age_weights[s], bounds_func(shifts[i] * exp_gamma[age_indices[s]], age_indices[s]))
# TODO: evaluate speed increase and accuracy decrease of the following:
#midpoint = age_indices[s][len(age_indices[s])/2]
#mu[i] = bounds_func(shifts[i] * exp_gamma[midpoint], midpoint)
# TODO: evaluate speed increase and accuracy decrease of the following: (to see speed increase, need to code this up using difference of running sums
#mu[i] = pl.dot(pl.ones_like(age_weights[s]) / float(len(age_weights[s])),
# bounds_func(shifts[i] * exp_gamma[age_indices[s]], age_indices[s]))
return mu
def connected_conponent(img):
"""
input: img cant be gray or color.
The shape of img is (height,width,..)
output: list of components and an image mask
"""
img.resize((10,10))
img = array(img)
assert(img.ndim>=2)
#mask = array([0]*img.size).reshape(img.shape)
mask = zeros_like(img,dtype=uint64) #[h,w]
comp_list = []
comp_index = 0 # the index of the first componet is 1
print mask.shape, mask.dtype
print img.shape,img.dtype
for y in range(img.shape[0]):
for x in range(img.shape[1]):
if mask[y,x]==0: # (y,x) will be a seed of component.
comp_index+=1
mask[y,x]=comp_index
#flood to ne
flood(img,mask,(y,x))
# Create Brownian paths
t = p.linspace(0, 3, n+1) # Partition [0,3] to 1000 partitions
dB = p.randn(n_path, n+1) / p.sqrt(n/3);
dB[:,0] = 0 # First column of dB is 0
B = dB.cumsum(axis=1) # Cummulative sum
# Calculate stock prices
nu = mu - sigma*sigma/2.0
S = p.zeros_like(B);
S[:,0] = S0
S[:, 1 :] = S0*p.exp(nu*t[1:]+sigma*B[:, 1 :])
# Plot 5 realizations of GBM
S_plot= S[0:5]
p.plot(t,S_plot.transpose());
p.xlabel('Time, $t$');
p.ylabel('Stock prices, $S_t$');
p.title('5 Realizations of Geometric Brownian Motion with ' '\n with $\mu$ = ' + str(mu) +' and $\sigma$ = ' + str(sigma) + '\n' )
p.show()
def GetGS(image_name, scale, roi=None, show=True, min_size=500, exclude_zones=None, flipudflag=False):
# Load image (Rappel pour convertir couleur to rgb color.rgb2gray)
if opencv:
original = cv2.imread(image_name)
else:
original = m.imread(image_name)
if flipudflag:
original = flipud(original)
# manage exclusion zone put them to 1 i.e. bottom
if exclude_zones != None:
# create markers of background and gravel
markers_zones = m.zeros_like(original[:, :, 0])
for zone in exclude_zones:
xa = min(zone[0], zone[2])
xb = max(zone[0], zone[2])
ya = min(zone[1], zone[3])
yb = max(zone[1], zone[3])
markers_zones[ya:yb, xa:xb] = 1
if roi != None:
# crop the image
xa = min(roi[0], roi[2])
xb = max(roi[0], roi[2])
ya = min(roi[1], roi[3])
yb = max(roi[1], roi[3])
original = original[ya:yb, xa:xb]
if exclude_zones != None:
markers_zones = markers_zones[ya:yb, xa:xb]
# transform to hsv
if opencv:
img = cv2.cvtColor(original, cv2.COLOR_BGR2HSV)
else:
img = color.rgb2hsv(original)
# use s chanel
img = img[:, :, 1]
# div by 255 si en couleur
thre = img
if show:
m.figure()
m.imshow(original)
# test filtre sobel (avoir les pentes)
if opencv:
elev = cv2.Laplacian(thre, cv2.CV_64F)
else:
elev = filters.sobel(thre)
# compute an auto threshold
thresh = filters.threshold_otsu(thre)
# create markers of background and gravel
markers = m.zeros_like(thre)
if show:
print thresh
markers[thre < thresh] = 2
markers[thre > thresh] = 1
if exclude_zones != None:
markers[markers_zones == 1] = 1
# use watershade transform (use markes as starting point)
segmentation = morphology.watershed(elev, markers)
# Clean small object
if opencv:
kernel = m.ones((2, 2), m.uint8)
closing = cv2.morphologyEx(segmentation - 1, cv2.MORPH_CLOSE, kernel)
else:
closing = ndimage.binary_closing(segmentation - 1)
tmp = ndimage.binary_fill_holes(closing)
label_objects, nb_labels = ndimage.label(tmp)
sizes = m.bincount(label_objects.ravel())
mask_sizes = sizes > min_size
mask_sizes[0] = 0
segmentation_cleaned = mask_sizes[label_objects]
# relabel cleaned version of segmentation
label_objects_clean, nb_label_clean = ndimage.label(segmentation_cleaned)
# plot contour of object
if show:
m.contour(ndimage.binary_fill_holes(label_objects_clean), linewidths=1.2, colors="y")
# trouve les informations des objets
# old version of scikit properties=measurement_types
mes = measure.regionprops(label_objects_clean)
granulo = []
for prop in mes:
# Correct orientation ! car orientation prend pas en compte le cadrant !!!
#: elements of the inertia tensor [a b; b c]
Orientation = GetOrientation(prop["CentralMoments"])
x0 = prop["Centroid"][1]
y0 = prop["Centroid"][0]
x1 = x0 + m.cos(Orientation) * 0.5 * prop["MajorAxisLength"]
y1 = y0 - m.sin(Orientation) * 0.5 * prop["MajorAxisLength"]
x2 = x0 - m.sin(Orientation) * 0.5 * prop["MinorAxisLength"]
y2 = y0 - m.cos(Orientation) * 0.5 * prop["MinorAxisLength"]
if show:
m.plot((x0, x1), (y0, y1), "-r", linewidth=2.5)
m.plot((x0, x2), (y0, y2), "-r", linewidth=2.5)
m.plot(x0, y0, ".g", markersize=15)
granulo.append(prop["MinorAxisLength"] / scale)
# minr, minc, maxr, maxc = prop['BoundingBox']
# bx = (minc, maxc, maxc, minc, minc)
# by = (minr, minr, maxr, maxr, minr)[
# m.plot(bx, by, '-b', linewidth=2.5)
return m.array(granulo), label_objects_clean, mes
[581, 537],
[602, 551],
[636, 561],
[656, 560],
[681, 542],
[712, 509],
[740, 482],
[771, 459],
[795, 447],
[826, 439],
[868, 439],
[907, 441],
]
)
points = pylab.zeros_like(pixels)
for i in xrange(len(pixels)):
points[i, 0] = (pixels[i, 0] - bottom_left[0]) * (top_right_values[0] - bottom_left_values[0]) / (
top_right[0] - bottom_left[0]
) + bottom_left_values[0]
points[i, 1] = (pixels[i, 1] - bottom_left[1]) * (top_right_values[1] - bottom_left_values[1]) / (
top_right[1] - bottom_left[1]
) + bottom_left_values[1]
# print points[i, 0], points[i, 1]
r = points[:, 0]
g = points[:, 1]
# pylab.plot(r, g)
dt = 10.0
t = numpy.arange(0,1000.0,dt)
rate = numpy.ones_like(t)*20.0
# stepup
i_start = t.searchsorted(400.0,'right')-1
i_end = t.searchsorted(600.0,'right')-1
rate[i_start:i_end] = 40.0
a = numpy.ones_like(t)*3.0
b = numpy.ones_like(t)/a/rate
psth = zeros_like(t)
stg = stgen.StGen()
trials = 5000
tsim = 1000.0
print "Running %d trials of %.2f milliseconds" % (trials, tsim)
for i in xrange(trials):
if i%100==0:
print "%d" % i,
sys.stdout.flush()
st = stg.inh_gamma_generator(a,b,t,1000.0,array=True)
psth[1:]+=numpy.histogram(st,t)[0]
print "\n"
def _create_plot_component():
path=os.path.join(os.getcwd())
A = glob.glob('*.chi')
A=np.sort(A)
s=len(A)
T = np.loadtxt('Temp.dat', unpack=True)
#T = sort(Temp)
Tlo = min(T)
Thi = max(T)
I0 = np.loadtxt("I0.dat",unpack=True)
fcmap = matplotlib.cm.get_cmap()
no_columns = 2*s-1
data = [np.loadtxt(f, usecols=[0, 1], unpack=False,skiprows=32) for f in A]
Data = np.concatenate(data, axis=1)
d = Data[:, r_[0, 1:no_columns:2]].T
savetxt(path+'Data_chi.dat',d, fmt='%g')
Data = np.loadtxt(path+'Data_chi.dat', unpack='True')
plt.figure()
plt.title("X-Ray Diffraction Data")
plt.xlabel("Q (${nm}^{-1}$)")
plt.ylabel("Intensity")
for i in range (1,s):
Ti = T[i - 1]
Ii = I0[i - 1]
color = fcmap((Ti - Tlo) / (1.0 * Thi - Tlo))
plt.plot(Data[:,0],Data[:,i] + (i*10000),color=color,alpha=.8)
plt.figure()
plt.title("X-Ray Diffraction Data")
plt.xlabel("Q (${nm}^{-1}$)")
plt.ylabel("Normalized Intensity")
for i in range (1,s):
Ti = T[i - 1]
Ii = I0[i - 1]
color = fcmap((Ti - Tlo) / (1.0 * Thi - Tlo))
plt.plot(Data[:,0],Data[:,i]/Ii + (i*10),color=color,alpha=.8)
fig = figure()
ax3 = Axes3D(fig)
pylab.title("X-ray Diffraction Data- WaterFall Plot")
pylab.xlabel("Q (${nm}^{-1}$)")
pylab.ylabel("Temperature (K)")
xi=Data[:,0]
# this sets the view elevation and azimuth in degrees
ax3.view_init(20, 220)
for i in range(1,s):
zi=Data[:,i] # zi=Data[p:q,0]
Ti = T[i - 1]
Ii = I0[i - 1]
color = fcmap((Ti - Tlo) / (1.0 * Thi - Tlo))
yi = (pylab.zeros_like(xi)+i)/Ii
ax3.plot(xi, (((yi/yi)-1)+Ti), zi, color=color)
# Give values to select the X and Y range
p=0
q=300
fig = figure()
ax3 = Axes3D(fig)
pylab.title("X-ray Diffraction Data- Normalized Intensity")
pylab.xlabel("Q (${nm}^{-1}$)")
pylab.ylabel("Temperature (K)")
xi=Data[p:q,0]
# this sets the view elevation and azimuth in degrees
ax3.view_init(20, 220)
for i in range(1,s):
Ti = T[i - 1]
Ii = I0[i - 1]
zi=Data[p:q,i]/Ii # zi=Data[p:q,0]
color = fcmap((Ti - Tlo) / (1.0 * Thi - Tlo))
yi = (pylab.zeros_like(xi)+i)/Ii
ax3.plot(xi, (((yi/yi)-1)+Ti), zi, color=color)
Itest = 5
Vmax = 15
#make grid
plotMargin = 1.2
sizex = Ca1.outer_radius*plotMargin
sizez = Ca1.outer_thickness*plotMargin
print sizex,sizez
size = np.max([sizex,sizez])
N=20.0 # number of grid points per axis
i=j=pb.arange(N)
n=float(N)
x = ((i/(n-1))-.5)*size*2
z = ((j/(n-1))-.5)*size*2
X,Z = pb.meshgrid(x,z)
Bx = pb.zeros_like(X)
Bz = pb.zeros_like(X)
Bnorm = pb.zeros_like(X)
#get B field
gaussPerTesla = 1e4
for ii in i:
for jj in j:
x = X[ii,jj]
z = Z[ii,jj]
if jj==0:
print ii,jj,x,z
B=(Ca1.Bvector([x,0,z])+Ca2.Bvector([x,0,z]))*gaussPerTesla
Bnorm[ii,jj] = norm(B)
Bx[ii,jj] = B[0]*np.log1p(np.fabs(1000*norm(B)))/norm(B)
Bz[ii,jj] = B[2]*np.log1p(np.fabs(1000*norm(B)))/norm(B)
dm = initialize_model()
dm.params['region_effect_prevalence'] = dict(std=level)
dismod3.neg_binom_model.fit_emp_prior(dm, 'prevalence', map_only=True)
models[-1].append(dm)
models.append([])
for level in [.1, 1, 10.]:
dm = initialize_model()
dm.params['beta_effect_prevalence'] = dict(mean=[0.], std=[level])
dismod3.neg_binom_model.fit_emp_prior(dm, 'prevalence', map_only=True)
models[-1].append(dm)
models.append([])
for level in [.2, 2., 20.]:
dm = initialize_model()
dm.params['gamma_effect_prevalence'] = dict(mean=list(pl.zeros_like(dm.get_estimate_age_mesh())),
std=list(level*pl.ones_like(dm.get_estimate_age_mesh())))
dismod3.neg_binom_model.fit_emp_prior(dm, 'prevalence', map_only=True)
models[-1].append(dm)
# this should change uncertainty, although it turns out not to change levels
models.append([])
for level in [.025, .25, 2.5]:
dm = initialize_model()
dm.params['delta_effect_prevalence'] = dict(mean=3.,
std=level)
dismod3.neg_binom_model.fit_emp_prior(dm, 'prevalence', map_only=True)
models[-1].append(dm)
freq_diff=p.diff(data_main.freqs)
main_ephase_tdelay=-main_ephase_diff/360.0/freq_diff
if last_main is not None:
main_nearest_pair_phase_diff=p.array(data_main.ephase)-p.array(last_main.ephase)
if card in middlecards:
interf_tdelay=p.array(data_interf.tdelay)
diff_tdelay=interf_tdelay-main_tdelay
phase_diff=p.array(data_interf.ephase)-p.array(data_main.ephase)
phase_diff=(phase_diff % 360.0)
phase_diff=p.array([(ph > 180) * -360 + ph for ph in phase_diff])
phase_diff_diff=p.diff(phase_diff)
phase_diff_tdelay=-(phase_diff_diff/360.0)/freq_diff
interf_ephase_diff=p.diff(data_interf.ephase)
interf_ephase_tdelay=-interf_ephase_diff/360.0/freq_diff
diff_ephase_tdelay=interf_ephase_tdelay-main_ephase_tdelay
smooth_phase_diff_tdelay=p.zeros_like(phase_diff_tdelay)
sum_count=p.zeros_like(phase_diff_tdelay)
for i in xrange(len(phase_diff_tdelay)):
for j in xrange(40):
if i+j < len(phase_diff_tdelay):
smooth_phase_diff_tdelay[i]+=phase_diff_tdelay[i+j]
sum_count[i]+=1
if i-j >= 0:
smooth_phase_diff_tdelay[i]+=phase_diff_tdelay[i-j]
sum_count[i]+=1
smooth_phase_diff_tdelay=smooth_phase_diff_tdelay/sum_count
if last_interf is not None:
interf_nearest_pair_phase_diff=p.array(data_interf.ephase)-p.array(last_interf.ephase)
p.figure(200+bmnum)
dm.description = 'With excess-mortality data removed'
dm.data = [d for d in dm.data if dm.relevant_to(d, 'all-cause_mortality', region, year, sex)] + \
[d for d in dm.data if dm.relevant_to(d, 'prevalence_x_excess-mortality', region, year, sex)] + \
[d for d in dm.data if d.get('country_iso3_code') == 'GBR']
dm.params['global_priors']['level_bounds']['excess_mortality'] = dict(lower=.2, upper=10.)
fit_posterior.fit_posterior(dm, region, sex, year, map_only=True, store_results=False)
models.append(dm)
dm = initialize_model()
dm.description = 'With excess-mortality data and priors removed'
dm.data = [d for d in dm.data if dm.relevant_to(d, 'all-cause_mortality', region, year, sex)] + \
[d for d in dm.data if dm.relevant_to(d, 'prevalence_x_excess-mortality', region, year, sex)] + \
[d for d in dm.data if d.get('country_iso3_code') == 'GBR']
dm.params['global_priors']['level_bounds']['excess_mortality'] = dict(lower=0., upper=10.)
dm.params['global_priors']['smoothness']['prevalence']['amount'] = 'No Prior'
dm.params['gamma_effect_excess-mortality'] = dict(mean=list(pl.zeros_like(dm.get_estimate_age_mesh())),
std=list(10.*pl.ones_like(dm.get_estimate_age_mesh())))
fit_posterior.fit_posterior(dm, region, sex, year, map_only=True, store_results=False)
models.append(dm)
dm = initialize_model()
dm.description = 'Without increasing prior on excess-mortality, but with "Very" smoothing'
dm.data = [d for d in dm.data if dm.relevant_to(d, 'all-cause_mortality', region, year, sex)] + \
[d for d in dm.data if dm.relevant_to(d, 'prevalence_x_excess-mortality', region, year, sex)] + \
[d for d in dm.data if d.get('country_iso3_code') == 'GBR'] + \
[d for d in dm.data if dm.relevant_to(d, 'excess-mortality', 'all', 'all', 'all')]
dm.params['global_priors']['smoothness']['prevalence']['amount'] = 'Very'
fit_posterior.fit_posterior(dm, region, sex, year, map_only=True, store_results=False)
models.append(dm)
Variance = (S0**2)*(p.exp(2*mu*time))*(p.exp(sigma*sigma*time)-1)
msg = 'The theoritical expected value of S(3) is %.13f' %Expected
print(msg)
msg = 'The theoritical vaiance of S(3) is %.13f' %Variance
print(msg)
#create brownian motion
t = p.linspace (0,3,n+1);
dB = p.randn(n_path, n+1) / p.sqrt(n/time); dB[:,0]=0;
B= dB.cumsum(axis=1);
#calculate stock price
nu = mu - sigma *sigma / 2.0
S = p.zeros_like(B); S[:,0]=S0
S[:,1:] = S0*p.exp (nu*t[1:] + sigma*B[:,1:])
S2 = S[0:5]
p.title('Brownian Motion')
p.xlabel('Time, $t$', fontsize=16)
p.ylabel('X(t)', fontsize=16)
p.plot(t,S2.transpose()); p.show();
#calculate expectation value of S(3)
S3=S[:,-1]
E= S3.sum() / n_path
msg = 'The expected value of S(3) is %.13f' %E
print(msg)
#calculate variance of S(3)
def smooth_rate(f=rate, age_indices=age_indices, C=C):
log_rate = pl.log(pl.maximum(f, NEARLY_ZERO))
return mc.mv_normal_cov_like(log_rate[age_indices] - log_rate[age_indices].mean(),
pl.zeros_like(age_indices),
C=C)
# Time-varying Rates
# ------------------
#
# When $b$ and $m$ are not constant with respect to time, the ODE does not have a closed form solution.
# If $b$ and $m$ are piecewise-constant, there an exact solution can be computed iteratively.
# <codecell>
h_b = .01*(2. - t/t.max())
h_m = .005*(2. + t/t.max())
# <codecell>
S_approx = scipy.integrate.odeint(one_compartment_ode, S_0, t, (h_b,h_m))
S_exact = 1. * pl.zeros_like(t)
S_exact[0] = S_0
for i in range(len(t)-1):
S_exact[i+1] = S_exact[i]*pl.exp((h_b[i]-h_m[i])*(t[i+1]-t[i]))
# <codecell>
# pl.figure()
# pl.plot(t, 100*(S_approx.reshape(101) - S_exact)/S_exact, 'k')
# pl.hlines([0],0,100,color='k',linestyle='--')
# pl.ylabel('Relative error (%)')
# pl.xlabel('Age (years)')
# yt = [-10e-5, 0, 10e-5, 20e-5, 30e-5]
# pl.yticks(yt, ['%.4f'%y for y in yt])
# pl.axis([-5,105,-10e-5, 30e-5])
# pl.title('ODE error for piecewise-constant rates')
