def comp_j(f, v, gas_params):
n, ux, uy, uz, T, rho, p, nu = comp_macro_params(f, v, gas_params)
cx = tt_from_factors(
(1. / ((2. * gas_params.Rg * T)**(1. / 2.))) * (v.vx_ - ux),
np.ones(v.nvy), np.ones(v.nvz))
cy = tt_from_factors(np.ones(
v.nvx), (1. / ((2. * gas_params.Rg * T)**(1. / 2.))) * (v.vy_ - uy),
np.ones(v.nvz))
cz = tt_from_factors(np.ones(v.nvx), np.ones(
v.nvy), (1. / ((2. * gas_params.Rg * T)**(1. / 2.))) * (v.vz_ - uz))
c2 = ((cx * cx) + (cy * cy) + (cz * cz)).round(1e-7) #, rmax = 2)
Sx = (1. / n) * v.hv3 * tt.sum(cx * c2 * f)
Sy = (1. / n) * v.hv3 * tt.sum(cy * c2 * f)
Sz = (1. / n) * v.hv3 * tt.sum(cz * c2 * f)
fmax = f_maxwell_tt(v, n, ux, uy, uz, T, gas_params.Rg)
f_plus = fmax * (v.ones + ((4. / 5.) * (1. - gas_params.Pr) *
(cx * Sx + cy * Sy + cz * Sz) *
((c2 - (5. / 2.) * v.ones))))
J = nu * (f_plus - f)
J = J.round(1e-7) #, rmax = 2)
return J, n, ux, uy, uz, T, rho, p, nu
def set_bc_tt(gas_params, bc_type, bc_data, f, vx, vy, vz, vn, vnp, vnm, tol):
"""Set boundary condition
"""
if (bc_type == 'sym-x'): # symmetry in x
l = f.to_list(f)
l[0] = l[0][:, ::-1, :]
return f.from_list(l)
elif (bc_type == 'sym-y'): # symmetry in y
l = f.to_list(f)
l[1] = l[1][:, ::-1, :]
return f.from_list(l)
elif (bc_type == 'sym-z'): # symmetry in z
l = f.to_list(f)
l[2] = l[2][:, ::-1, :]
return f.from_list(l)
elif (bc_type == 'sym'): # zero derivative
return f.copy()
elif (bc_type == 'in'): # inlet
# unpack bc_data
return bc_data[0]
elif (bc_type == 'out'): # outlet
# unpack bc_data
return bc_data[0]
elif (bc_type == 'wall'): # wall
# unpack bc_data
fmax = bc_data[0]
hv = vx[1, 0, 0] - vx[0, 0, 0]
Ni = (hv**3) * tt.sum((f * vnp).round(tol))
Nr = (hv**3) * tt.sum((fmax * vnm).round(tol))
n_wall = -Ni / Nr
return n_wall * fmax
def comp_macro_params(f, v, gas_params):
# takes "F" with (1, 1, 1, 1) ranks to perform to_list function
# takes precomputed "ones_tt" tensor
# "ranks" array for mean ranks
# much less rounding
n = v.hv3 * tt.sum(f)
if n <= 0.:
n = 1e+10
ux = (1. / n) * v.hv3 * tt.sum(v.vx_tt * f)
uy = (1. / n) * v.hv3 * tt.sum(v.vy_tt * f)
uz = (1. / n) * v.hv3 * tt.sum(v.vz_tt * f)
u2 = ux * ux + uy * uy + uz * uz
T = (1. / (3. * n * gas_params.Rg)) * (v.hv3 * tt.sum((v.v2 * f)) - n * u2)
if T <= 0.:
T = 1.
rho = gas_params.m * n
p = rho * gas_params.Rg * T
mu = gas_params.mu(T)
nu = p / mu
return n, ux, uy, uz, T, rho, p, nu
def sum(self):
if self.isnone:
return None
if self.mode == MODE_NP or self.mode == MODE_SP:
return np.sum(self.x)
if self.mode == MODE_TT:
return tt.sum(self.x)
def set_bc(gas_params, bc_type, bc_data, f, v, vn, vnp, vnm, tol):
"""Set boundary condition
"""
if (bc_type == 'sym-x'): # symmetry in x
return reflect_tt(f, 'x')
elif (bc_type == 'sym-y'): # symmetry in y
return reflect_tt(f, 'y')
elif (bc_type == 'sym-z'): # symmetry in z
return reflect_tt(f, 'z')
elif (bc_type == 'sym'): # zero derivative
return f.copy()
elif (bc_type == 'in'): # inlet
# unpack bc_data
return bc_data[0]
elif (bc_type == 'out'): # outlet
# unpack bc_data
return bc_data[0]
elif (bc_type == 'wall'): # wall
# unpack bc_data
fmax = bc_data[0]
Ni = v.hv3 * tt.sum((f * vnp).round(tol))
Nr = v.hv3 * tt.sum((fmax * vnm).round(tol))
n_wall = -Ni / Nr
return n_wall * fmax
# alpha_prior, beta_prior = gamma_params(rates,rates / np.array([1000,250,25,900]))
mu = rates[:-1] * np.array([1.5, 1.5, 1.5, 1.0, 1.0])
var = rates[:-1] * np.array([4 / 3, 5, 0.25, 0.04, 0.2])
alpha_prior = mu**2 / var
beta_prior = mu / var
Pt = tt.tensor(gamma_pdf(pts1, alpha_prior[0], beta_prior[0]))
Pt = tt.kron(Pt, tt.tensor(gamma_pdf(pts2, alpha_prior[1], beta_prior[1])))
Pt = tt.kron(Pt, tt.tensor(gamma_pdf(pts3, alpha_prior[2], beta_prior[2])))
Pt = tt.kron(Pt, tt.tensor(gamma_pdf(pts4, alpha_prior[3], beta_prior[3])))
Pt = tt.kron(Pt, tt.tensor(gamma_pdf(pts5, alpha_prior[4], beta_prior[4])))
# Pt = tt.tensor(np.ones([Nl,Nl]))
WS = tt.kron(
tt.kron(tt.kron(tt.tensor(ws1), tt.tensor(ws2)),
tt.kron(tt.tensor(ws3), tt.tensor(ws4))), tt.tensor(ws5))
Z = tt.sum(Pt * WS)
Pt = Pt * (1 / Z)
Pt_prior = Pt
P = tt.kron(tt.tensor(x0), Pt)
P = P * (1 / tt.sum(P * tt.kron(tt.ones(N), WS)))
plt.figure()
plt.plot(pts1, gamma_pdf(pts1, alpha_prior[0], beta_prior[0]))
plt.figure()
plt.plot(pts2, gamma_pdf(pts2, alpha_prior[1], beta_prior[1]))
plt.figure()
plt.plot(pts3, gamma_pdf(pts3, alpha_prior[2], beta_prior[2]))
plt.figure()
plt.plot(pts4, gamma_pdf(pts4, alpha_prior[3], beta_prior[3]))
plt.figure()
plt.plot(pts5, gamma_pdf(pts5, alpha_prior[4], beta_prior[4]))
plt.pause(0.05)
def comp_macro_param_and_j_tt(f, vx_, vx, vy, vz, vx_tt, vy_tt, vz_tt, v2,
gas_params, tol, F, ones_tt):
# takes "F" with (1, 1, 1, 1) ranks to perform to_list function
# takes precomputed "ones_tt" tensor
# "ranks" array for mean ranks
# much less rounding
Rg = gas_params.Rg
hv = vx_[1] - vx_[0]
n = (hv**3) * tt.sum(f)
ux = (1. / n) * (hv**3) * tt.sum(vx_tt * f)
uy = (1. / n) * (hv**3) * tt.sum(vy_tt * f)
uz = (1. / n) * (hv**3) * tt.sum(vz_tt * f)
u2 = ux * ux + uy * uy + uz * uz
T = (1. / (3. * n * Rg)) * ((hv**3) * tt.sum((v2 * f)) - n * u2)
Vx = vx - ux
Vy = vy - uy
Vz = vz - uz
Vx_tt = (vx_tt - ux * ones_tt).round(tol)
Vy_tt = (vy_tt - uy * ones_tt).round(tol)
Vz_tt = (vz_tt - uz * ones_tt).round(tol)
rho = gas_params.m * n
p = rho * Rg * T
cx = Vx_tt * (1. / ((2. * Rg * T)**(1. / 2.)))
cy = Vy_tt * (1. / ((2. * Rg * T)**(1. / 2.)))
cz = Vz_tt * (1. / ((2. * Rg * T)**(1. / 2.)))
c2 = ((cx * cx) + (cy * cy) + (cz * cz)).round(tol)
Sx = (1. / n) * (hv**3) * tt.sum(cx * c2 * f)
Sy = (1. / n) * (hv**3) * tt.sum(cy * c2 * f)
Sz = (1. / n) * (hv**3) * tt.sum(cz * c2 * f)
mu = gas_params.mu(T)
fmax = F
fmax_list = F.to_list(F)
fmax_list[0][0, :, 0] = np.exp(-((vx_ - ux)**2) /
(2. * Rg * T)) # vx_ instead of Vx[0, :, :]
fmax_list[1][0, :, 0] = np.exp(-((vx_ - uy)**2) / (2. * Rg * T))
fmax_list[2][0, :, 0] = np.exp(-((vx_ - uz)**2) / (2. * Rg * T))
fmax = fmax.from_list(fmax_list)
fmax = n * ((1. / (2. * np.pi * Rg * T))**(3. / 2.)) * fmax
fmax = fmax.round(tol)
#fmax = tt.tensor(f_maxwell(vx, vy, vz, T, n, ux, uy, uz, gas_params.Rg))
f_plus = fmax * (ones_tt + ((4. / 5.) * (1. - gas_params.Pr) *
(cx * Sx + cy * Sy + cz * Sz) *
((c2 - (5. / 2.) * ones_tt))))
f_plus = f_plus.round(tol)
J = (f_plus - f) * (p / mu)
J = J.round(tol)
nu = p / mu
return J, n, ux, uy, uz, T, nu, rho, p
' ', y)
tme = datetime.datetime.now()
P = fwd_int.solve(P, dT, intervals=Nbs, qtt=qtt, verb=False, rounding=True)
tme = datetime.datetime.now() - tme
print('\tmax rank ', max(P.r))
Ppred = P
Ppost = PO * Ppred
Ppost = Ppost.round(1e-10)
print('\tmax rank (after observation) ', max(Ppost.r))
if tensor_size < tt_size(Ppost): tensor_size = tt_size(Ppost)
if not qtt:
Ppost = Ppost * (1 / tt.sum(Ppost * tt.kron(tt.ones(N), WS)))
Pt = tt.sum(tt.sum(tt.sum(tt.sum(Ppost, 0), 0), 0), 0)
Z = tt.sum(Pt * WS)
Pt = Pt * (1 / Z)
Pt = Pt.round(1e-10)
else:
Ppost = Ppost * (1 / tt.sum(
Ppost * tt.kron(tt.ones(int(np.sum(np.log2(N))) * [2]), ws_qtt)))
Pt = Ppost
for i in range(int(np.sum(np.log2(N)))):
Pt = tt.sum(Pt, 0)
Z = tt.sum(Pt * ws_qtt)
Pt = Pt * (1 / Z)
Pt = Pt.round(1e-10)
def solve(self,
initial_tt,
T,
intervals=None,
return_all=False,
nswp=40,
qtt=False,
verb=False,
rounding=True):
if intervals == None:
pass
else:
x_tt = initial_tt
dT = T / intervals
Nt = self.N_max
S, P, ev, basis = self.get_SP(dT, Nt)
if qtt:
nqtt = int(np.log2(Nt))
S = ttm2qttm(tt.matrix(S))
P = ttm2qttm(tt.matrix(P))
I_tt = tt.eye(self.A_tt.n)
B_tt = tt.kron(I_tt, tt.matrix(S)) - tt.kron(
I_tt, P) @ tt.kron(self.A_tt, ttm2qttm(tt.eye([Nt])))
else:
nqtt = 1
I_tt = tt.eye(self.A_tt.n)
B_tt = tt.kron(I_tt, tt.matrix(S)) - tt.kron(
I_tt, tt.matrix(P)) @ tt.kron(self.A_tt,
tt.matrix(np.eye(Nt)))
# print(dT,T,intervals)
returns = []
for i in range(intervals):
# print(i)
if qtt:
f_tt = tt.kron(x_tt, tt2qtt(tt.tensor(ev)))
else:
f_tt = tt.kron(x_tt, tt.tensor(ev))
# print(B_tt.n,f_tt.n)
try:
# xs_tt = xs_tt.round(1e-10,5)
# tme = datetime.datetime.now()
xs_tt = tt.amen.amen_solve(B_tt,
f_tt,
self.xs_tt,
self.epsilon,
verb=1 if verb else 0,
nswp=nswp,
kickrank=8,
max_full_size=50,
local_prec='n')
# tme = datetime.datetime.now() - tme
# print(tme)
self.xs_tt = xs_tt
except:
# tme = datetime.datetime.now()
xs_tt = tt.amen.amen_solve(B_tt,
f_tt,
f_tt,
self.epsilon,
verb=1 if verb else 0,
nswp=nswp,
kickrank=8,
max_full_size=50,
local_prec='n')
# tme = datetime.datetime.now() - tme
# print(tme)
self.xs_tt = xs_tt
# print('SIZE',tt_size(xs_tt)/1e6)
# print('PLMMM',tt.sum(xs_tt),xs_tt.r)
if basis == None:
if return_all: returns.append(xs_tt)
x_tt = xs_tt[tuple([slice(None, None, None)] *
len(self.A_tt.n) + [-1] * nqtt)]
x_tt = x_tt.round(self.epsilon / 10)
else:
if return_all:
if qtt:
beval = basis(np.array([0])).flatten()
temp1 = xs_tt * tt.kron(tt.ones(self.A_tt.n),
tt2qtt(tt.tensor(beval)))
for l in range(nqtt):
temp1 = tt.sum(temp1, len(temp1.n) - 1)
beval = basis(np.array([dT])).flatten()
temp2 = xs_tt * tt.kron(tt.ones(self.A_tt.n),
tt2qtt(tt.tensor(beval)))
for l in range(nqtt):
temp2 = tt.sum(temp2, len(temp2.n) - 1)
returns.append(
tt.kron(temp1, tt.tensor(np.array([1, 0]))) +
tt.kron(temp2, tt.tensor(np.array([0, 1]))))
else:
beval = basis(np.array([0])).flatten()
temp1 = xs_tt * tt.kron(tt.ones(self.A_tt.n),
tt.tensor(beval))
temp1 = tt.sum(temp1, len(temp1.n) - 1)
beval = basis(np.array([dT])).flatten()
temp2 = xs_tt * tt.kron(tt.ones(self.A_tt.n),
tt.tensor(beval))
temp2 = tt.sum(temp2, len(temp2.n) - 1)
returns.append(
tt.kron(temp1, tt.tensor(np.array([1, 0]))) +
tt.kron(temp2, tt.tensor(np.array([0, 1]))))
beval = basis(np.array([dT])).flatten()
if qtt:
x_tt = xs_tt * tt.kron(tt.ones(self.A_tt.n),
tt2qtt(tt.tensor(beval)))
for l in range(nqtt):
x_tt = tt.sum(x_tt, len(x_tt.n) - 1)
if rounding: x_tt = x_tt.round(self.epsilon / 10)
else:
x_tt = tt.sum(
xs_tt *
tt.kron(tt.ones(self.A_tt.n), tt.tensor(beval)),
len(xs_tt.n) - 1)
if rounding: x_tt = x_tt.round(self.epsilon / 10)
# print('SIZE 2 ',tt_size(x_tt)/1e6)
if not return_all: returns = x_tt
return returns
P_fwd = [P.copy()]
ranks_fwd = [[0, max(P.r)]]
time = 0
for i in range(1, No):
y = observations[i, :]
Po1 = noise_model(np.arange(N[0]), y[0], s1)
Po2 = noise_model(np.arange(N[1]), y[1], s2)
Po3 = noise_model(np.arange(N[2]), y[2], s3)
Po4 = noise_model(np.arange(N[3]), y[3], s4)
Po = tt.kron(tt.kron(tt.tensor(Po1), tt.tensor(Po2)),
tt.kron(tt.tensor(Po3), tt.tensor(Po4)))
Po = Po * (1 / tt.sum(Po))
if qtt: Po = tt2qtt(Po)
tme = timeit.time.time()
P = fwd_int.solve(P, dT, intervals=6, return_all=True, qtt=qtt)
# for p in P:
# print('\t',p.r)
if qtt:
P_fwd += [
p[tuple([slice(None, None, None)] * len(A_qtt.n) +
[-1])].round(1e-8) for p in P
]
for k in range(len(P)):
time += dT / len(P)
if qtt:
A_qtt = ttm2qttm(Att)
integrator = ttInt(A_qtt,
epsilon=1e-7,
N_max=8,
dt_max=1.0,
method='cheby')
P = tt2qtt(P)
else:
integrator = ttInt(Att,
epsilon=1e-7,
N_max=64,
dt_max=1.0,
method='crank–nicolson')
for i in range(25):
dt = 12
tme = timeit.time.time()
P = integrator.solve(P, dt, intervals=12, qtt=True)
tme = timeit.time.time() - tme
print(i, ' time ', tme, ' ', P.r)
# P = P.round(1e-8,80)
P = qtt2tt(P, N)
P_D = tt.sum(tt.sum(tt.sum(tt.sum(tt.sum(P, 0), 0), 0), 0), 1).full()
plt.figure()
plt.plot(P_D)
Prior1 = GammaPDF(alpha_prior[0], beta_prior[0], basis[0], param_range[0][0], param_range[0][1])
Prior2 = GammaPDF(alpha_prior[1], beta_prior[1], basis[1], param_range[1][0], param_range[1][1])
Prior3 = GammaPDF(alpha_prior[2], beta_prior[2], basis[2], param_range[2][0], param_range[2][1])
Prior4 = GammaPDF(alpha_prior[3], beta_prior[3], basis[3], param_range[3][0], param_range[3][1])
Prior5 = GammaPDF(alpha_prior[4], beta_prior[4], basis[4], param_range[4][0], param_range[4][1])
Priors = [Prior1 , Prior2 , Prior3 , Prior4 , Prior5]
Prior = Prior1 ** Prior2 ** Prior3 ** Prior4 ** Prior5
Puniform = UniformPDF(basis, param_range)
print('Initial E ',Prior.expected_value())
print('Initial C ',Prior.covariance_matrix())
P = tt.kron(P,Prior.tt)
P = P * (1/tt.sum(P * tt.kron(tt.ones(N),WS)))
Post = pdfTT(basis, param_range)
for i in range(5):
plm = Prior.marginal(np.eye(5)[i,:])
x = np.linspace(plm.basis[0].domain[0],plm.basis[0].domain[1],1000)
B = plm.basis[0](x)
plt.figure()
plt.plot(x,np.einsum('ij,i->j',B,plm.tt.full()))
plt.pause(0.05)
#%% integrator
if qtt:
def test_base(self):
m1 = tt.sum(self.Z)
m2 = teneva.sum(self.Y)
self.assertTrue(_err(m1, m2) < self.e)
def test_base(self):
m1 = tt.sum(self.Z) / np.prod([G.shape[1] for G in self.Y])
m2 = teneva.mean(self.Y)
self.assertTrue(_err(m1, m2) < self.e)
plt.plot(time_sample, np.mean(sample[:, 0, :], 1), 'b')
plt.plot(time_sample, np.mean(sample[:, 1, :], 1), 'orange')
plt.plot(time_sample, np.mean(sample[:, 2, :], 1), 'r')
plt.plot(time_sample, np.mean(sample[:, 3, :], 1), 'g')
plt.legend(['Susceptible', 'Exposed', 'Infected', 'Recovered'])
plt.ylabel(r'#individuals')
plt.xlabel(r'$t$ [d]')
#%% Integrate ODE
A_tt = mdl.construct_generator_tt()
# A_tt = tt.reshape(A_tt,np.array(2*[[15]*8]).transpose())
P = tt.kron(tt.kron(tt.tensor(p1), tt.tensor(p2)),
tt.kron(tt.tensor(p3), tt.tensor(p4)))
P = P * (1 / tt.sum(P))
P0 = P
# P = tt.reshape(P,[15]*8)
x_S = tt.kron(tt.tensor(np.arange(N[0])), tt.ones(N[1:]))
x_E = tt.kron(tt.ones([N[0]]),
tt.kron(tt.tensor(np.arange(N[1])), tt.ones(N[2:])))
x_I = tt.kron(tt.ones(N[:2]),
tt.kron(tt.tensor(np.arange(N[2])), tt.ones([N[3]])))
x_R = tt.kron(tt.ones(N[:3]), tt.tensor(np.arange(N[3])))
epsilon = 1e-10
rmax = 30
#%% reference ode solution
# print('Reference...')