def find_gb_local(theta,phi,system, fm_width, n_orbitals=2, delta=0.01, omega=0, topo=True): """ Find localized Gilbert Damping as function of theta,phi for individual atomic sites. """ n_layers = system.n_layers u_theta = np.array([[np.cos(theta/2), 1*np.sin(theta/2)],[-1*np.sin(theta/2),np.cos(theta/2)]], dtype=np.complex_) u_phi = np.array([[np.exp(1.j*phi/2),0],[0,np.exp(-1.j*phi/2)]], dtype=np.complex_) u = np.dot(u_theta,u_phi) u_dag = calc.hermitian(u) v = sparse.kron(np.identity(n_orbitals*system.sites),np.dot(u_dag,np.dot(np.array([[0,1],[0,0]], dtype=np.complex_),u))).toarray() v_array = np.zeros((n_layers, n_layers), dtype=np.complex_) for num in range(fm_width): v_array[num,num] = 1 v_array = sparse.kron(v_array,v).toarray() img = (system.greens_ret - calc.hermitian(system.greens_ret)) / 2.j system.update_energy(system.energy+omega) img_2 =(system.greens_ret - calc.hermitian(system.greens_ret)) / 2.j d = (delta**2)*np.diag(np.dot(img,np.dot(v_array,np.dot(img_2,calc.hermitian(v_array))))) if topo: lgb = d[1::4] + d[::4]+d[2::4]+d[3::4] dos = np.diag(img) ldos_maj = dos[::4] + dos[2::4] ldos_min = dos[1::4] + dos[3::4] else: lgb = d[1::2] + d[::2] dos = np.diag(img) ldos_maj = dos[::2] ldos_min = dos[1::2] return [np.real(lgb),np.real(ldos_maj),np.real(ldos_min),np.real(dos)]
def mod_greens(system,tol,magmom=1,delta=0.02,boson_dist=0,max_iters=500,mixing=0.5): greens = system.greens_ret greens_list = [] greens_list.append(greens) i = 0 iters = 0 diff = 1000 while diff>tol: iters+=1 i = 1 if iters>=max_iters: break greens_up = greens[::2,::2] img_1 = greens_up / 1.j greens_down = greens[1::2,1::2] img_2 = greens_down / 1.j img_1 = sparse.kron(img_1,np.array([[0,0],[0,1]])) img_2 = sparse.kron(img_2,np.array([[1,0],[0,0]])) img_comb = img_1 + img_2 coeff = (1.j)*(delta**2)*(1/magmom)*(boson_dist + 0.5) sigma_l = system.sigma_l + coeff*img_comb greens_new = (mixing)*system.combine(system.hamil, system.e_array, sigma_l, system.sigma_r, system.sites, system.n_layers)+(1-mixing)* greens greens = greens_new greens_list.append(greens) diff = linalg.norm(greens_list[i]-greens_list[i-1]) greens_list.pop(0) return greens
def __init__(self, fine_bp, coarse_bp, int_orders, rstr_orders, *args, **kwargs):
"""Initialization routine for transfer operators
Args:
fine_bp : BlockProblem on fine level
coarse_bp : Blockproblem on coarse level
int_orders (list of int):
coarse_orders (list of int):
*args: Variable length argument list
**kwargs: Arbitrary keyword arguments
"""
assert isinstance(fine_bp, BlockProblemBase)
assert isinstance(coarse_bp, BlockProblemBase)
assert fine_bp.n_layer == len(int_orders) and coarse_bp.n_layer == len(rstr_orders)
f_grids = map(lambda x: np.linspace(0, 1, x.shape[0]), fine_bp.As[0])
c_grids = map(lambda x: np.linspace(0, 1, x.shape[0]), coarse_bp.As[0])
intpl_matrices = map(lambda fg, cg, x: interpolation_matrix_1d(fg, cg, x),
f_grids, c_grids, int_orders)
rstr_matrices = map(lambda fg, cg, x: 0.5 * interpolation_matrix_1d(fg, cg, x).transpose(),
f_grids, c_grids, rstr_orders)
self.I_2htoh = reduce(lambda a, b: sp.kron(a, b, format='csc'), intpl_matrices)
self.I_hto2h = reduce(lambda a, b: sp.kron(a, b, format='csc'), rstr_matrices)
super(EquidistantBlockTransfer, self).__init__(fine_bp.ndofs, coarse_bp.ndofs, *args, **kwargs)
def rand_Jacobian_matrix(n): I = SS.eye(n,n) data = NY.random.rand(3,n) B = SS.spdiags(data,[0,-1,1],n,n) A = SS.kron(B,I) + SS.kron(I,B) return A
def enlarge_block(block):
"""This function enlarges the provided Block by a single site, returning an
EnlargedBlock.
"""
mblock = block.basis_size
o = block.operator_dict
# Create the new operators for the enlarged block. Our basis becomes a
# Kronecker product of the Block basis and the single-site basis. NOTE:
# `kron` uses the tensor product convention making blocks of the second
# array scaled by the first. As such, we adopt this convention for
# Kronecker products throughout the code.
enlarged_operator_dict = {
"H": kron(o["H"], identity(model_d)) + kron(identity(mblock), H1) + H2(o["conn_Sz"], o["conn_Sp"], Sz1, Sp1),
"conn_Sz": kron(identity(mblock), Sz1),
"conn_Sp": kron(identity(mblock), Sp1),
}
# This array keeps track of which sector each element of the new basis is
# in. `np.add.outer()` creates a matrix that adds each element of the
# first vector with each element of the second, which when flattened
# contains the sector of each basis element in the above Kronecker product.
enlarged_basis_sector_array = np.add.outer(block.basis_sector_array, single_site_sectors).flatten()
return EnlargedBlock(length=(block.length + 1),
basis_size=(block.basis_size * model_d),
operator_dict=enlarged_operator_dict,
basis_sector_array=enlarged_basis_sector_array)
def _K(self, g, beta, ifix=None):
""" Returns the discretised integral operator
"""
if ifix is None:
ifix = self.ifix
g = g.reshape(self.dim.R, self.dim.N).T # set g as g_{nr}, n=1..N, r=1..R
g = np.column_stack((np.ones(self.dim.N), g)) # append a col. of 1s to g
# matrices A[r] = sum(b_rd * Ld
struct_mats = np.array([sum(brd*Ld for brd, Ld in zip(br, self.basis_mats))
for br in beta])
# Add an axis for n=0,...,N-1
At = struct_mats[None, :, :, :] * g[..., None, None]
At = At.sum(1)
W = weight_matrix(self.ttc, ifix) #self._weight_matrix
K = sum(sparse.kron(sparse.kron(W[:, i][:, None],
sparse.eye(1, self.dim.N, i)),
At[i, ...])
for i in range(self.dim.N))
I = sparse.eye(self.dim.K)
# because x[ifix] is fixed by the integral transform
# we need to add a column of identity matrices to K
# - could do this by assignment
eifix = sparse.eye(1, self.dim.N, ifix)
K += sum(sparse.kron(sparse.kron(sparse.eye(1, self.dim.N, i).transpose(),
eifix),
I)
for i in range(self.dim.N))
return K
def _laplace(self):
'''
construct Laplace operator as a matrix
based on user input filter.
Actually this matrix can be thought
as a convolution operator:
f(x,z)*U(x,z)
'''
f=[-1.,2.,-1.]
nx = nz = self.n
nf = len(f)
nonzero = np.ones((nf,nx))
for i in range(nf):
nonzero[i] *=f[i]
offsets = array(range(nf/2,-nf/2 ,-1))
m1 = dia_matrix((nonzero,offsets),shape=(nx,nx))
m2 = identity(nz)
k1 = kron(m1,m2)
nonzero = np.ones((nf,nz))
for i in range(nf):
nonzero[i,:] *=f[i]
m1 = dia_matrix((nonzero,offsets),shape=(nz,nz))
m2 = identity(nx)
k2 = kron(m2,m1)
return k1+ k2
def _conserved_get_proj(p_basis,dtype): np_min = p_basis._n.min() np_max = p_basis._n.max() v_ph = _np.zeros((np_max+1,1),dtype=_np.int32) proj_1 = p_basis._b1.get_proj(dtype).tocsc() proj_1_mask = _sp.csc_matrix(proj_1.shape,dtype=dtype) v_ph[np_min] = 1 mask = p_basis._n == np_min proj_1_mask[:,mask] = proj_1[:,mask] proj_1_full = _sp.kron(proj_1_mask,v_ph,format="csr") proj_1_mask[:,mask]=0.0 proj_1_mask.eliminate_zeros() v_ph[np_min] = 0 for np in xrange(np_min+1,np_max+1,1): v_ph[np] = 1 mask = p_basis._n == np proj_1_mask[:,mask] = proj_1[:,mask] proj_1_full = proj_1_full + _sp.kron(proj_1_mask,v_ph,format="csr") proj_1_mask[:,mask]=0.0 proj_1_mask.eliminate_zeros() v_ph[np] = 0
def __init__(self, Y, a, b, c, d, H, q=None):
'''
Q_{i,j} = a*(y_i*y_j)^3+b*(y_i*y_j)^2+c*(y_i+y_j) + d - h_i*h_j
q = q
'''
super(AMF_deg3_BQP, self).__init__()
n, l = Y.shape
self.a = a
self.b = b
self.c = c
self.d = d
self.Y1 = Y
self.H = H # mostly updated
if q is None:
self.q = np.zeros(n)
else:
self.q = q
# consider 2nd and 3nd power of Y
Y2_tmp = []
Y3_tmp = []
for i in xrange(n):
y = Y.getrow(i)
Y2_tmp.append(kron(y, y))
Y3_tmp.append(kron(kron(y, y), y))
self.Y2 = vstack(Y2_tmp).tocsr()
self.Y3 = vstack(Y3_tmp).tocsr()
def pauli_x(n, N):
'''compute the pauli_x operator acting on the n^th spin of N'''
px = Pauli['x']
e1, e2 = sp.eye(2**(n-1)), sp.eye(2**(N-n))
return sp.kron(e1, sp.kron(px, e2))
def vectorize(self, dependency_graph):
nodes = dependency_graph.nodes
if self.operator == 'head':
assert len(nodes[0]['deps']) == 1
head_address, = nodes[0]['deps']['ROOT']
return self.node_to_vector(nodes[head_address])
elif self.operator in ('add', 'mult'):
tokens = tuple((node['lemma'], node['tag']) for node in nodes.values() if node['address'])
return getattr(self.space, self.operator)(*tokens)
elif self.operator in self.transitive_operators:
assert graph_signature(dependency_graph) == transitive_sentence(self.tagset)
subject = self.node_to_vector(nodes[1])
verb = self.node_to_vector(nodes[2])
object_ = self.node_to_vector(nodes[3])
if self.operator == 'kron':
verb_matrix = sparse.kron(verb, verb, format='csr')
subject_object = sparse.kron(subject, object_, format='csr')
return verb_matrix.multiply(subject_object)
else:
raise NotImplemented('Operator {} is not implemented'.format(self.operator))
else:
raise ValueError('Operator {} is not supported'.format(self.operator))
def die(first_noun, second_noun, trans_verb):
"""Vectorize a sentence with 'noun die noun verb' = (sub, obj)."""
noun_model = space.words.polyglot_model()
noun_space = noun_model[0]
die_vector = compose.train.die_cat_stored()
ver_vector = compose.train.verb(trans_verb, noun_model)
fst_vector = noun_space[first_noun]
snd_vector = noun_space[second_noun]
par_vector_sub = kron(
csr_matrix(snd_vector), csr_matrix(ver_vector))
par_vector_obj = kron(
csr_matrix(snd_vector), numpy.transpose(csr_matrix(ver_vector)))
par_vector_sub = kron(
numpy.transpose(csr_matrix(fst_vector)), csr_matrix(par_vector_sub))
par_vector_obj = kron(
numpy.transpose(csr_matrix(fst_vector)), csr_matrix(par_vector_obj))
vector_sub = numpy.multiply(csr_matrix(die_vector), par_vector_sub)
vector_obj = numpy.multiply(csr_matrix(die_vector), par_vector_obj)
return (vector_sub.toarray().flatten(), vector_obj.toarray().flatten())
def get_preconditioner():
"""Compute the preconditioner M"""
diags_x = zeros((3, nx))
diags_x[0,:] = 1/hx/hx
diags_x[1,:] = -2/hx/hx
diags_x[2,:] = 1/hx/hx
Lx = spdiags(diags_x, [-1,0,1], nx, nx)
diags_y = zeros((3, ny))
diags_y[0,:] = 1/hy/hy
diags_y[1,:] = -2/hy/hy
diags_y[2,:] = 1/hy/hy
Ly = spdiags(diags_y, [-1,0,1], ny, ny)
J1 = kron(Lx, eye(ny)) + kron(eye(nx), Ly)
# Now we have the matrix `J_1`. We need to find its inverse `M` --
# however, since an approximate inverse is enough, we can use
# the *incomplete LU* decomposition
J1_ilu = spilu(J1)
# This returns an object with a method .solve() that evaluates
# the corresponding matrix-vector product. We need to wrap it into
# a LinearOperator before it can be passed to the Krylov methods:
M = LinearOperator(shape=(nx*ny, nx*ny), matvec=J1_ilu.solve)
return M
def fget(self):
if(self._nodalLaplacian is None):
print 'Warning: Laplacian has not been tested rigorously.'
# The number of cell centers in each direction
n = self.vnC
# Compute divergence operator on faces
if(self.dim == 1):
D1 = sdiag(1./self.hx) * ddx(mesh.nCx)
L = - D1.T*D1
elif(self.dim == 2):
D1 = sdiag(1./self.hx) * ddx(n[0])
D2 = sdiag(1./self.hy) * ddx(n[1])
L1 = sp.kron(speye(n[1]+1), - D1.T * D1)
L2 = sp.kron(- D2.T * D2, speye(n[0]+1))
L = L1 + L2
elif(self.dim == 3):
D1 = sdiag(1./self.hx) * ddx(n[0])
D2 = sdiag(1./self.hy) * ddx(n[1])
D3 = sdiag(1./self.hz) * ddx(n[2])
L1 = kron3(speye(n[2]+1), speye(n[1]+1), - D1.T * D1)
L2 = kron3(speye(n[2]+1), - D2.T * D2, speye(n[0]+1))
L3 = kron3(- D3.T * D3, speye(n[1]+1), speye(n[0]+1))
L = L1 + L2 + L3
self._nodalLaplacian = L
return self._nodalLaplacian
def srmax_loop(D, env, w, track, damping=0.001, rmax = 1.0):
"""
Sparse rmax loop.
"""
k = len(w)
A = sp.identity(k,format='csr') * damping
b = sp_create(k,1,'csr')
grmax = rmax / (1.0 - env.gamma)
for (s,a,r,ns,na) in D:
if track.known_pair(s,a) and track.known_state(ns):
features = env.phi(s, a, sparse=True, format='csr')
next = env.linear_policy(w, ns)
newfeatures = env.phi(ns, next, sparse=True, format='csr')
nf = features - env.gamma * newfeatures
T = sp.kron(features, nf.T)
A = A + T
b = b + features * r
elif track.known_pair(s,a):
features = env.phi(s, a, sparse=True, format='csr')
T = sp.kron(features, features.T)
A = A + T
b = b + features * (r + env.gamma * grmax)
else:
features = env.phi(s, a, sparse=True, format='csr')
T = sp.kron(features, features.T)
A = A + T
b = b + features * grmax
for una in track.unknown(s):
features = env.phi(s, una, sparse=True, format='csr')
T = sp.kron(features, features.T)
A = A + T
b = b + features * grmax
return A,b
def __init__(self,bksize,numbk):
n = 2*bksize*numbk # Degrees of freedom per dimension
self.L = neglap2d(n)
T = spdiags(np.ones((2,n)),np.array([0,1]),n,n) # Matrix for overlaps
Id = np.identity(4)
Esz = np.ones((bksize,bksize)) # Template for size of blocks
Enm = np.ones((numbk,numbk)) # Template for numbe of blocks
# Four colors of subdomain
self.colors = ('blue','yellow','red','green')
self.dex = [] # Indices of colored subdomains
self.S = [] # Operator on each subdomain
for k in xrange(4): # Loop over four colors of subdomains
# Determine color of subdomains associated with grid points
q = csr_matrix(np.reshape(Id[:,k],(2,2)))
mat = T*kron(kron(Enm,q),Esz)*T
row,col = mat.nonzero()
self.dex.append(n*row+col)
self.S.append(self.L[:,self.dex[k]][self.dex[k],:])
def self_energy(E, H, t, sigma_0, a, iterations,N): """ Finds the self-energy at a given supercell by using a mixing coefficient. More iterations will give a more accurate sigma (self-energy) value, although there may not be convergence in all cases. """ t_array = sparse.kron(np.identity(N), t).toarray() t_dagger_array = hermitian(t_array) e_array = sparse.kron(np.identity(H.shape[0]), E).toarray() sigma = sparse.kron(np.eye(H.shape[0], dtype=np.complex_),sigma_0).toarray() tol = 1e-7 i = 0 sigmas = [] sigmas.append(sigma) i = 0 iters = 0 diff = 1000 while diff>tol: sigma = (sigma * a) + np.dot(t_dagger_array,np.dot(linalg.inv(e_array - H - sigma),t_array)) * (1 - a) sigmas.append(sigma) i = 1 iters += 1 diff = linalg.norm(np.absolute(sigmas[i]-sigmas[i-1])) if iters > 1000: break sigmas.pop(0) return sigma
def sparse_cH(terms, ldim=2):
"""Construct a sparse cyclic nearest-neighbour Hamiltonian
:param terms: List of nearst-neighbour terms (square array or MPO,
see return value of :func:`cXY_local_terms`)
:param ldim: Local dimension
:returns: The Hamiltonian as sparse matrix
"""
H = 0
N = len(terms)
for pos, term in enumerate(terms[:-1]):
if hasattr(term, 'lt'):
# Convert MPO to regular matrix
term = term.to_array_global().reshape((ldim**2, ldim**2))
left = sp.eye(ldim**pos)
right = sp.eye(ldim**(N - pos - 2))
H += sp.kron(left, sp.kron(term, right))
# The last term acts on the first and last site.
cyc = terms[-1]
middle = sp.eye(ldim**pos)
for i in range(cyc.ranks[0]):
H += sp.kron(cyc.lt[0][0, ..., i], sp.kron(middle, cyc.lt[1][i, ..., 0]))
return H
def gen_gamma(N):
'''compute sum of tunneling term for a single zone'''
if N==1:
return sx
return sp.kron(gen_gamma(N-1), eye) + sp.kron(sp.eye(2**(N-1)), sx)
def construct_hams(hs, Js, Jxs):
'''Construct static Hamiltonians'''
Nz = len(hs) # number of zones
H0s = [construct_H0(hs[i], Js[i]) for i in xrange(Nz)]
Gammas = [gen_gamma(len(hs[i])) for i in xrange(Nz)]
M = [H.size for H in H0s] # number of states per zone
C = [1]+list(np.cumprod(M)) # cumprod of H0 sizes
# pad single zone Hamiltonians
for i in xrange(Nz):
H0s[i] = np.tile(np.repeat(H0s[i], C[-1]/C[i+1]), [1, C[i]])
Gammas[i] = sp.kron(sp.eye(C[i]), sp.kron(Gammas[i], sp.eye(C[-1]/C[i+1])))
# only need sum of H0s
H0 = np.sum(np.array(H0s), axis=0)
# add zone-zone interactions to H0
for i,j in Jxs:
Jx = Jxs[(i,j)]
Hx = np.zeros([1, M[i]*M[j]], dtype=float)
for n,m in zip(*Jx.nonzero()):
Hx += Jx[n, m]*np.kron(pauli_z(n+1, Jx.shape[0]),
pauli_z(m+1, Jx.shape[1]))
if np.any(Hx):
H0 += np.tile(np.repeat(Hx, C[i]), [1, C[-1]/C[j+1]])
H0 = sp.diags(H0, [0])
return H0, Gammas
def __init__(self,lhgen,rhgen,target_sector=0.,joint=True):
self.lhgen=deepcopy(lhgen)
self.rhgen=deepcopy(rhgen)
self.L=self.lhgen.l+self.rhgen.l
self.H=kron(self.lhgen.H,identity(self.rhgen.D))+kron(identity(self.lhgen.D),self.rhgen.H)
if joint==True:
for lpterm in self.lhgen.pterms:
for rpterm in self.rhgen.pterms:
if lpterm.label==rpterm.label: #label must include all the important imformation
self.H=self.H+kron(lpterm.current_op.mat,rpterm.current_op.mat)*lpterm.param
self.target_sector=target_sector
self.sector_indices={}
self.rsector_indices={}
self.restricted_basis_indices=[]
for sys_sec,sys_basis_states in self.lhgen.basis_by_sector.items():
self.sector_indices[sys_sec]=[]
env_sec=target_sector-sys_sec
if env_sec in self.rhgen.basis_by_sector:
self.rsector_indices[env_sec]=[]
for i in sys_basis_states:
i_offset=self.rhgen.D*i
for j in self.rhgen.basis_by_sector[env_sec]:
current_index=len(self.restricted_basis_indices)
self.sector_indices[sys_sec].append(current_index)
self.rsector_indices[env_sec].append(current_index)
self.restricted_basis_indices.append(i_offset+j)
self.restricted_superblock_hamiltonian=self.H.todense()[:,self.restricted_basis_indices][self.restricted_basis_indices,:]
def randomModel(shape, seed=None, anisotropy=None, its=100, bounds=None):
"""
Create a random model by convolving a kernel with a
uniformly distributed model.
:param tuple shape: shape of the model.
:param int seed: pick which model to produce, prints the seed if you don't choose.
:param numpy.ndarray anisotropy: this is the (3 x n) blurring kernel that is used.
:param int its: number of smoothing iterations
:param list bounds: bounds on the model, len(list) == 2
:rtype: numpy.ndarray
:return: M, the model
.. plot::
import matplotlib.pyplot as plt
import SimPEG.Utils.ModelBuilder as MB
plt.colorbar(plt.imshow(MB.randomModel((50,50),bounds=[-4,0])))
plt.title('A very cool, yet completely random model.')
plt.show()
"""
if bounds is None:
bounds = [0,1]
if seed is None:
seed = np.random.randint(1e3)
print 'Using a seed of: ', seed
if type(shape) in [int, long, float]:
shape = (shape,) # make it a tuple for consistency
np.random.seed(seed)
mr = np.random.rand(*shape)
if anisotropy is None:
if len(shape) is 1:
smth = np.array([1,10.,1],dtype=float)
elif len(shape) is 2:
smth = np.array([[1,7,1],[2,10,2],[1,7,1]],dtype=float)
elif len(shape) is 3:
kernal = np.array([1,4,1], dtype=float).reshape((1,3))
smth = np.array(sp.kron(sp.kron(kernal,kernal.T).todense()[:],kernal).todense()).reshape((3,3,3))
else:
assert len(anisotropy.shape) is len(shape), 'Anisotropy must be the same shape.'
smth = np.array(anisotropy,dtype=float)
smth = smth/smth.sum() # normalize
mi = mr
for i in range(its):
mi = ndi.convolve(mi, smth)
# scale the model to live between the bounds.
mi = (mi - mi.min())/(mi.max()-mi.min()) # scaled between 0 and 1
mi = mi*(bounds[1]-bounds[0])+bounds[0]
return mi
def sfermion(L): H=np.zeros((4,4)) d=1 for i in range(L-1): H=kron(H,identity(4))+t*kron(kron(identity(d),Cp_up.dot(Zs)),Cm_up)-t*kron(kron(identity(d),Cm_up.dot(Zs)),Cp_up)+t*kron(kron(identity(d),Cp_dn.dot(Zs)),Cm_dn)-t*kron(kron(identity(d),Cm_dn.dot(Zs)),Cp_dn) d*=4 E0,psi0=eigsh(H,k=1,which='SA') print E0/L
def __init__(self, transfer_list, *args, **kwargs):
for t in transfer_list:
assert hasattr(t, 'I_2htoh') and hasattr(t, 'I_hto2h')
self.I_2htoh = reduce(lambda a, b: sp.kron(a.I_2htoh, b.I_2htoh, format='csc'), transfer_list)
self.I_hto2h = reduce(lambda a, b: sp.kron(a.I_hto2h, b.I_hto2h, format='csc'), transfer_list)
n_f = reduce(lambda a, b: a.ndofs_fine * b.ndofs_fine, transfer_list)
n_c = reduce(lambda a, b: a.ndofs_coarse * b.ndofs_coarse, transfer_list)
super(CombinedBlockTransfer, self).__init__(n_f, n_c)
def localop(Operator, site, chainlength, dimpersite):
II = I(dimpersite)
sitesbefore = site - 1
sitesafter = chainlength - site
O1 = bigkronecker(II, sitesbefore)
O2 = bigkronecker(II, sitesafter)
return sparse.kron(sparse.kron(O1, site), O2)
def H2(self, b1, b2): # two-site part of H
"""Given the operator b on two sites in different Hilbert spaces
(e.g. two blocks), returns a Kronecker product representing the
corresponding two-site term in the Hamiltonian that joins the two
sites.
"""
return -self.t * (kron(b1, b2.conjugate().transpose()) +
kron(b1.conjugate().transpose(), b2))
def BuildLaPoisson():
"""
pour l'etape de projection
matrice de Laplacien phi
avec CL Neumann pour phi
BUT condition de Neumann pour phi
==> non unicite de la solution
besoin de fixer la pression en un point
pour lever la degenerescence: ici [0][1]
==> need to build a correction matrix
"""
### ne pas prendre en compte les points fantome (-2)
NXi = nx
NYi = ny
###### Definition of the 1D Lalace operator
###### AXE X
### Diagonal terms
dataNXi = [numpy.ones(NXi), -2*numpy.ones(NXi), numpy.ones(NXi)]
### Conditions aux limites : Neumann à gauche, rien à droite
dataNXi[2][1] = 2. # SF left
# dataNXi[0][NXi-2] = 2. # SF right
###### AXE Y
### Diagonal terms
dataNYi = [numpy.ones(NYi), -2*numpy.ones(NYi), numpy.ones(NYi)]
### Conditions aux limites : Neumann
dataNYi[2][1] = 2. # SF low
dataNYi[0][NYi-2] = 2. # SF top
###### Their positions
offsets = numpy.array([-1,0,1])
DXX = sp.dia_matrix((dataNXi,offsets), shape=(NXi,NXi)) * dx_2
DYY = sp.dia_matrix((dataNYi,offsets), shape=(NYi,NYi)) * dy_2
####### 2D Laplace operator
LAP = sp.kron(sp.eye(NYi,NYi), DXX) + sp.kron(DYY, sp.eye(NXi,NXi))
####### BUILD CORRECTION MATRIX
### Upper Diagonal terms
dataNYNXi = [numpy.zeros(NYi*NXi)]
offset = numpy.array([1])
### Fix coef: 2+(-1) = 1 ==> Dirichlet en un point (redonne Laplacien)
### ATTENTION COEF MULTIPLICATIF : dx_2 si M(j,i) j-NY i-NX
dataNYNXi[0][1] = -1 * dx_2
LAP0 = sp.dia_matrix((dataNYNXi,offset), shape=(NYi*NXi,NYi*NXi))
return LAP + LAP0
def generate_plot():
h_bar = 6.582E-16
q = 1
a = 1E-10
t = 1
c = 3.0E8
g = -2.002
N = 1
E = -1
Ez = 1000
eta = 0.01 + (0.01)*1.j
sigma_x = np.array([[0,1],[1,0]])
sigma_y = np.array([[0, -1.j],[1.j,0]])
kxs = []
alphas = []
stxs = []
stys = []
for kx in pl.frange(0, 2*np.pi, 0.1):
kxs.append(kx)
kys = []
alphas_row = []
stxs_row = []
stys_row = []
for ky in pl.frange(0, 2*np.pi, 0.1):
coeff = (-1)*g*q*(1/(h_bar**2))*(a**2)*(t**2)*(1/(2*c**2))
#print(coeff)
hamil = sparse.kron(np.identity(2, dtype=np.complex_), t*(np.cos(kx)+np.cos(ky)))
hamil += coeff*(np.cos(kx) + np.cos(ky))*(Ez*np.sin(ky)*sigma_x - Ez*np.sin(kx)*sigma_y)
E_arr = sparse.kron(np.identity(2, dtype=np.complex_),E).toarray()
greens = linalg.inv(E_arr-hamil-eta)
img = (greens - calc.hermitian(greens))/(2.j)
stxs_row.append(np.trace(np.dot(img,sigma_x))/2)
stys_row.append(np.trace(np.dot(img,sigma_y))/2)
kys.append(ky)
alpha = np.trace(img)/2
alphas_row.append(alpha)
#print(stxs_row)
alphas.append(alphas_row)
stxs.append(stxs_row)
stys.append(stys_row)
print(kx)
print('loop over')
x, y = np.meshgrid(kxs, kys)
print('here')
#print(alphas)
alphas = np.array(alphas)
stxs = np.array(stxs)
stys = np.array(stys)
print(stxs)
#print(alphas)
#fig = plt.figure()
plt.pcolormesh(x, y, alphas)
#plt.pcolormesh(x,y,stxs)
plt.quiver(x, y, stxs, stys, color='red', angles='xy', scale_units='xy', scale=1)
#plt.quiver(x, y, stys, color='red', headlength=10)
print('mesh complete')
#plt.colorbar()
plt.show()
def LaplacianSmooth(self, reference_mesh):
# placing this down here for now in case people are having numpy/scipy problems
import numpy
import scipy.sparse as sparse
import scipy.sparse.linalg
num_vertices = len(self.vertices)
num_boundary_vertices = len(self.boundary_vertices)
num_non_boundary_vertices = num_vertices - num_boundary_vertices
L = sparse.lil_matrix((num_vertices, num_vertices))
C = sparse.lil_matrix((num_boundary_vertices, num_vertices))
Cbar = sparse.lil_matrix((num_non_boundary_vertices, num_vertices))
non_boundary_vertices_seen = 0
boundary_vertices_seen = 0
for i in xrange(num_vertices):
if i in self.boundary_vertices:
C[boundary_vertices_seen, i] = 1.0
boundary_vertices_seen += 1
else:
Cbar[non_boundary_vertices_seen, i] = 1.0
non_boundary_vertices_seen += 1
assert (num_boundary_vertices == boundary_vertices_seen)
assert (num_non_boundary_vertices == non_boundary_vertices_seen)
C = sparse.kron(C, sparse.eye(3, 3)).tocsr()
Cbar = sparse.kron(Cbar, sparse.eye(3, 3)).tocsr()
edge_boundary_vertices = 0
edge_non_boundary_vertices = 0
for v0, v1 in self.edges:
if v0 in self.boundary_vertices:
edge_boundary_vertices += 1
else:
edge_non_boundary_vertices += 1
if v1 in self.boundary_vertices:
edge_boundary_vertices += 1
else:
edge_non_boundary_vertices += 1
weight = 1.0
L[v0,v0] -= weight
L[v0,v1] += weight
L[v1,v1] -= weight
L[v1,v0] += weight
L = sparse.kron(L, sparse.eye(3, 3)).tocsr()
xtilde = numpy.array(self.vertices).flatten()
y = numpy.array(reference_mesh.vertices).flatten()
CbarLTL = Cbar * (L.T * L)
b = CbarLTL * (y - C.T * (C * xtilde))
xbar, info = sparse.linalg.cg(CbarLTL * Cbar.T, b)
x = Cbar.T * xbar + C.T * (C * xtilde)
self.vertices = x.reshape(numpy.array(self.vertices).shape)
def sparse_discrete_diff(n):
'''
Sparse discrete difference matrix on a grid
:param n: for the n by n grid
:return: sparse discrete difference matrix
'''
d = sparse.diags([-1, 1], [0, 1], shape = (n-1, n))
id = sparse.identity(n)
return sparse.vstack([sparse.kron(d,id), sparse.kron(id,d)])
def configure(self,
H_sys,
coup_op,
coup_strength,
temperature,
N_cut,
N_exp,
cut_freq,
planck=None,
boltzmann=None,
renorm=None,
bnd_cut_approx=None,
options=None,
progress_bar=None,
stats=None):
"""
Calls configure from :class:`HEOMSolver` and sets any attributes
that are specific to this subclass
"""
start_config = timeit.default_timer()
HEOMSolver.configure(self,
H_sys,
coup_op,
coup_strength,
temperature,
N_cut,
N_exp,
planck=planck,
boltzmann=boltzmann,
options=options,
progress_bar=progress_bar,
stats=stats)
self.cut_freq = cut_freq
if renorm is not None: self.renorm = renorm
if bnd_cut_approx is not None: self.bnd_cut_approx = bnd_cut_approx
# Load local values for optional parameters
# Constants and Hamiltonian.
hbar = self.planck
options = self.options
progress_bar = self.progress_bar
stats = self.stats
if stats:
ss_conf = stats.sections.get('config')
if ss_conf is None:
ss_conf = stats.add_section('config')
c, nu = self._calc_matsubara_params()
if renorm:
norm_plus, norm_minus = self._calc_renorm_factors()
if stats:
stats.add_message('options', 'renormalisation', ss_conf)
# Dimensions et by system
sup_dim = H_sys.dims[0][0]**2
unit_sys = qeye(H_sys.dims[0])
# Use shorthands (mainly as in referenced PRL)
lam0 = self.coup_strength
gam = self.cut_freq
N_c = self.N_cut
N_m = self.N_exp
Q = coup_op # Q as shorthand for coupling operator
beta = 1.0 / (self.boltzmann * self.temperature)
# Ntot is the total number of ancillary elements in the hierarchy
# Ntot = factorial(N_c + N_m) / (factorial(N_c)*factorial(N_m))
# Turns out to be the same as nstates from state_number_enumerate
N_he, he2idx, idx2he = enr_state_dictionaries([N_c + 1] * N_m, N_c)
unit_helems = sp.identity(N_he, format='csr')
if self.bnd_cut_approx:
# the Tanimura boundary cut off operator
if stats:
stats.add_message('options', 'boundary cutoff approx', ss_conf)
op = -2 * spre(Q) * spost(Q.dag()) + spre(Q.dag() * Q) + spost(
Q.dag() * Q)
approx_factr = ((2 * lam0 /
(beta * gam * hbar)) - 1j * lam0) / hbar
for k in range(N_m):
approx_factr -= (c[k] / nu[k])
L_bnd = -approx_factr * op.data
L_helems = sp.kron(unit_helems, L_bnd)
else:
L_helems = sp.csr_matrix((N_he * sup_dim, N_he * sup_dim),
dtype=complex)
# Build the hierarchy element interaction matrix
if stats: start_helem_constr = timeit.default_timer()
unit_sup = spre(unit_sys).data
spreQ = spre(Q).data
spostQ = spost(Q).data
commQ = (spre(Q) - spost(Q)).data
N_he_interact = 0
for he_idx in range(N_he):
he_state = list(idx2he[he_idx])
n_excite = sum(he_state)
# The diagonal elements for the hierarchy operator
# coeff for diagonal elements
sum_n_m_freq = 0.0
for k in range(N_m):
sum_n_m_freq += he_state[k] * nu[k]
op = -sum_n_m_freq * unit_sup
L_he = _pad_csr(op, N_he, N_he, he_idx, he_idx)
L_helems += L_he
# Add the neighour interations
he_state_neigh = copy(he_state)
for k in range(N_m):
n_k = he_state[k]
if n_k >= 1:
# find the hierarchy element index of the neighbour before
# this element, for this Matsubara term
he_state_neigh[k] = n_k - 1
he_idx_neigh = he2idx[tuple(he_state_neigh)]
op = c[k] * spreQ - np.conj(c[k]) * spostQ
if renorm:
op = -1j * norm_minus[n_k, k] * op
else:
op = -1j * n_k * op
L_he = _pad_csr(op, N_he, N_he, he_idx, he_idx_neigh)
L_helems += L_he
N_he_interact += 1
he_state_neigh[k] = n_k
if n_excite <= N_c - 1:
# find the hierarchy element index of the neighbour after
# this element, for this Matsubara term
he_state_neigh[k] = n_k + 1
he_idx_neigh = he2idx[tuple(he_state_neigh)]
op = commQ
if renorm:
op = -1j * norm_plus[n_k, k] * op
else:
op = -1j * op
L_he = _pad_csr(op, N_he, N_he, he_idx, he_idx_neigh)
L_helems += L_he
N_he_interact += 1
he_state_neigh[k] = n_k
if stats:
stats.add_timing('hierarchy contruct',
timeit.default_timer() - start_helem_constr,
ss_conf)
stats.add_count('Num hierarchy elements', N_he, ss_conf)
stats.add_count('Num he interactions', N_he_interact, ss_conf)
# Setup Liouvillian
if stats: start_louvillian = timeit.default_timer()
H_he = sp.kron(unit_helems, liouvillian(H_sys).data)
L_helems += H_he
if stats:
stats.add_timing('Liouvillian contruct',
timeit.default_timer() - start_louvillian,
ss_conf)
if stats: start_integ_conf = timeit.default_timer()
r = scipy.integrate.ode(cy_ode_rhs)
r.set_f_params(L_helems.data, L_helems.indices, L_helems.indptr)
r.set_integrator('zvode',
method=options.method,
order=options.order,
atol=options.atol,
rtol=options.rtol,
nsteps=options.nsteps,
first_step=options.first_step,
min_step=options.min_step,
max_step=options.max_step)
if stats:
time_now = timeit.default_timer()
stats.add_timing('Liouvillian contruct',
time_now - start_integ_conf, ss_conf)
if ss_conf.total_time is None:
ss_conf.total_time = time_now - start_config
else:
ss_conf.total_time += time_now - start_config
self._ode = r
self._N_he = N_he
self._sup_dim = sup_dim
self._configured = True
def DVR_Matrix_3D(self):
#X
DVRMatrix3Dx = []
FORTRANoffset = 1
for i in xrange(self.cfg.NGRIDX):
for idash in xrange(self.cfg.NGRIDX):
if i == idash:
DVRMatrix3Dx.append([
FORTRANoffset + i, FORTRANoffset + idash,
self.cfg.HBAR * (-1.0)**np.abs(i - idash) /
(2.0 * self.cfg.MASS * self.cfg.h**2.0) *
np.pi**(2.0) / 3.0, 1.0
])
elif i != idash:
DVRMatrix3Dx.append([
FORTRANoffset + i, FORTRANoffset + idash,
self.cfg.HBAR * (-1.0)**np.abs(i - idash) /
(2.0 * self.cfg.MASS * self.cfg.h**2.0) * 2.0 /
(i - idash)**2.0, 1.0
])
DVRMatrix3Dx = np.array(DVRMatrix3Dx)
rowx = DVRMatrix3Dx[:, 0] - 1
colx = DVRMatrix3Dx[:, 1] - 1
dataAx = DVRMatrix3Dx[:, 2]
Ax = sp.coo_matrix((dataAx, (rowx, colx)),
shape=(self.cfg.NGRIDX, self.cfg.NGRIDX))
#Y
DVRMatrix3Dy = []
FORTRANoffset = 1
for i in xrange(self.cfg.NGRIDY):
for idash in xrange(self.cfg.NGRIDY):
if i == idash:
DVRMatrix3Dy.append([
FORTRANoffset + i, FORTRANoffset + idash,
self.cfg.HBAR * (-1.0)**np.abs(i - idash) /
(2.0 * self.cfg.MASS * self.cfg.hY**2.0) *
np.pi**(2.0) / 3.0, 1.0
])
elif i != idash:
DVRMatrix3Dy.append([
FORTRANoffset + i, FORTRANoffset + idash,
self.cfg.HBAR * (-1.0)**np.abs(i - idash) /
(2.0 * self.cfg.MASS * self.cfg.hY**2.0) * 2.0 /
(i - idash)**2.0, 1.0
])
DVRMatrix3Dy = np.array(DVRMatrix3Dy)
rowy = DVRMatrix3Dy[:, 0] - 1
coly = DVRMatrix3Dy[:, 1] - 1
dataAy = DVRMatrix3Dy[:, 2]
Ay = sp.coo_matrix((dataAy, (rowy, coly)),
shape=(self.cfg.NGRIDY, self.cfg.NGRIDY))
#Y
DVRMatrix3Dz = []
FORTRANoffset = 1
for i in xrange(self.cfg.NGRIDZ):
for idash in xrange(self.cfg.NGRIDZ):
if i == idash:
DVRMatrix3Dz.append([
FORTRANoffset + i, FORTRANoffset + idash,
self.cfg.HBAR * (-1.0)**np.abs(i - idash) /
(2.0 * self.cfg.MASS * self.cfg.hZ**2.0) *
np.pi**(2.0) / 3.0, 1.0
])
elif i != idash:
DVRMatrix3Dz.append([
FORTRANoffset + i, FORTRANoffset + idash,
self.cfg.HBAR * (-1.0)**np.abs(i - idash) /
(2.0 * self.cfg.MASS * self.cfg.hZ**2.0) * 2.0 /
(i - idash)**2.0, 1.0
])
DVRMatrix3Dz = np.array(DVRMatrix3Dz)
rowz = DVRMatrix3Dz[:, 0] - 1
colz = DVRMatrix3Dz[:, 1] - 1
dataAz = DVRMatrix3Dz[:, 2]
Az = sp.coo_matrix((dataAz, (rowz, colz)),
shape=(self.cfg.NGRIDZ, self.cfg.NGRIDZ))
#XYZ
D3 = sp.coo_matrix(
sp.kron(sp.kron(Ax, sp.eye(self.cfg.NGRIDY)),
sp.eye(self.cfg.NGRIDZ)) +
sp.kron(sp.kron(sp.eye(self.cfg.NGRIDX), Ay),
sp.eye(self.cfg.NGRIDZ)) +
sp.kron(sp.kron(sp.eye(self.cfg.NGRIDX), sp.eye(self.cfg.NGRIDY)),
Az))
#ADD V(x,y)
return D3 + self.cfg.V
# list/ array to store transformation/ truncation matrices for wave function transformation. UENVL = [] UENVR = [] # Construct Sz, S+ and S- for a single site sqtwo = 1.41421356237309504880168872421 Sz = np.array([[1.0, 0, 0], [0, 0, 0], [0, 0, -1.0]], dtype='d') Sp = np.array([[0, sqtwo, 0], [0, 0, sqtwo], [0, 0, 0]], dtype='d') Sm = np.array([[0, 0, 0], [sqtwo, 0, 0], [0, sqtwo, 0]], dtype='d') #Initial Hamiltonians for left and right sides; two site Hamiltonians. HL = kron(Sz, Sz) + 0.5 * (kron(Sp, Sm) + kron(Sm, Sp)) HR = kron(Sz, Sz) + 0.5 * (kron(Sp, Sm) + kron(Sm, Sp)) # Adding HR to the list; refer to p. 1691 of notes HRMAT.append(HR) HLMAT.append(HL) # Initialising matrices for growth SztL = Sz SptL = Sp SmtL = Sm SztR = Sz SptR = Sp
if z[k] == -1:
T = T
elif (z[k] >= m):
T = T
else:
T[i, j, z[k]] = T[i, j, z[k]] + (-1)**k
# COMPUTE THE RANK OF THE KOSZUL FLATTENING
p = int(input("p = "))
d = int(nCr(m, p))
# S: B* \to A \otimes C
Tf = T.reshape(m, m * m)
Tf = sparse.csr_matrix(Tf)
print(Tf.shape)
#print(np.linalg.matrix_rank(Tf))
# Id_Skew \otimes S: L^p A \otimes B^* \to L^p A \otimes A \otimes C
K = sparse.kron(np.eye(d), Tf)
print(K.shape)
#Projection L^p \otimes A to L^{p+1}A
aa = a(int(m), int(p))
aa = sparse.csr_matrix(aa)
#Kronecker product with C
P = sparse.kron(aa.T, np.eye(m))
P = sparse.csr_matrix(P)
print(P.shape)
TAp = K @ P
print(TAp.shape)
def radius(eps):
H_star = np.linalg.inv(np.identity(len(Hc)) - Hc2.dot(eps ** 2)).dot(Hc)
return approx_spectral_radius(kron(H_star, W).dot(eps) - kron(Hc.dot(H_star), D).dot(eps ** 2), pyamg=pyamg) - 1
def unbalance_longwas_fixed(data_file,
id,
tpoint,
trait,
bed_file,
kin_file,
var_com,
snp_lst=None,
tfix=None,
fix=None,
forder=3,
aorder=3,
porder=3,
na_method='omit',
prefix_outfile='unbalance_longwas_fixed'):
"""
the longitudinal GWAS for the unbalanced data treating the SNP as the time varied fixed effect.
:param data_file: the data file. The first row is the variate names whose first initial position is alphabetical.
For the class variates, the first letter must be capital; for the covariates (continuous variates), the first letter
must be lowercase.
:param id: A class variate name which indicates the individual id column in the data file.
:param tpoint: A covariate names which indicates the time point column in the data file.
:param trait: A variate name which indicates the analyzed trait column in the data file.
:param bed_file: the prefix for the plink binary file.
:param kin_file: the file for genomic relationship matrix. This file can be produced by
gmat.gmatrix.agmat function using agmat(bed_file, inv=True, small_val=0.001, out_fmt='id_id_val')
:param var_com: the estimated variance parameters by the gmat.longwas.unbalance.unbalance_varcom function.
:param snp_lst: the snp list to test. Default is None.
:param tfix: A class variate name for the time varied fixed effect. Default value is None. Only one time varied
fixed effect can be included in the current version.
:param fix: Expression for the time independent fixed effect. Default value is None. An example:
fix = "Sex + age + Season".
:param forder: the order of Legendre polynomials for the time varied fixed effect. The default value is 3.
:param aorder: the order of Legendre polynomials for the additive genetic effect. The default value is 3.
:param porder: the order of Legendre polynomials for the permanent environment effect. The default value is 3.
:param na_method: The method to deal with missing values. The default value is 'omit'. 'omit' method will delete the
row with missing values. 'include' method will fill the missing values with the adjacent values.
:param prefix_outfile: the prefix for the output file. Default is 'unbalance_longwas_fixed'.
:return: A pandas data frame for the test result.
"""
logging.info('################################')
logging.info('###Prepare the related matrix###')
logging.info('################################')
if var_com.shape[0] != aorder * (aorder + 1) / 2 + aorder + 1 + porder * (
porder + 1) / 2 + porder + 1 + 1:
logging.info('ERROR: Variances do not match the data, please check')
exit()
logging.info('***Read the data file***')
logging.info('Data file: ' + data_file)
data_df = pd.read_csv(data_file, sep='\s+', header=0)
logging.info('NA method: ' + na_method)
if na_method == 'omit':
data_df = data_df.dropna()
elif na_method == 'include':
data_df = data_df.fillna(method='ffill')
data_df = data_df.fillna(method='bfill')
else:
logging.info('na_method does not exist: ' + na_method)
exit()
col_names = data_df.columns
logging.info('The column names of data file: ' + ' '.join(list(col_names)))
logging.info(
'Note: Variates beginning with a capital letter is converted into factors.'
)
class_vec = []
for val in col_names:
if not val[0].isalpha():
logging.info(
"The first character of columns names must be alphabet!")
exit()
if val[0] == val.capitalize()[0]:
class_vec.append(val)
data_df[val] = data_df[val].astype('str')
else:
try:
data_df[val] = data_df[val].astype('float')
except Exception as e:
logging.info(e)
logging.info(val + " may contain string, please check!")
exit()
logging.info('Individual column: ' + id)
if id not in col_names:
logging.info(id + ' is not in the data file, please check!')
exit()
if id not in class_vec:
logging.info('The initial letter of {} should be capital'.format(id))
exit()
id_order = []
id_arr = list(data_df[id])
id_order.append(id_arr[0])
for i in range(1, len(id_arr)):
if id_arr[i] != id_arr[i - 1]:
id_order.append(id_arr[i])
id_in_data = set(data_df[id])
if len(id_in_data) - len(id_order) != 0:
logging.info('The data is not sored by individual ID!')
exit()
logging.info('Time points column: ' + tpoint)
if tpoint not in col_names:
logging.info(tpoint + ' is not in the data file, please check!')
exit()
if tpoint in class_vec:
logging.info(
'The initial letter of {} should be lowercase'.format(tpoint))
exit()
logging.info('Trait column: ' + trait)
if trait not in col_names:
logging.info(trait + ' is not in the data file, please check!')
exit()
if trait in class_vec:
logging.info(
'The initial letter of {} should be lowercase'.format(trait))
exit()
logging.info('Code factor variables of the data file: ' +
' '.join(list(class_vec)))
code_val = {}
code_dct = dct_2D()
for val in class_vec:
code_val[val] = 0
temp = []
for i in range(data_df.shape[0]):
if data_df[val][i] not in code_dct[val]:
code_val[val] += 1
code_dct[val][data_df[val][i]] = str(code_val[val])
temp.append(code_dct[val][data_df[val][i]])
data_df[val] = np.array(temp)
for val in class_vec:
data_df[val] = data_df[val].astype('int')
logging.info('***Build the design matrix for fixed effect***')
logging.info('Time dependent fixed effect: ' + str(tfix))
leg_fix = leg(data_df[tpoint], forder)
if tfix == None:
xmat_t = np.concatenate(leg_fix, axis=1)
xmat_t = csr_matrix(xmat_t)
else:
if tfix not in class_vec:
logging.info(tfix + ' is not the class variate')
exit()
row = np.array(range(data_df.shape[0]))
col = np.array(data_df[tfix]) - 1
val = np.array([1.0] * data_df.shape[0])
tfix_mat = csr_matrix((val, (row, col)))
xmat_t = []
for i in range(len(leg_fix)):
xmat_t.append(tfix_mat.multiply(leg_fix[i]))
xmat_t = hstack(xmat_t)
del row, col, val
gc.collect()
logging.info('Time independent fix effect: ' + str(fix))
xmat_nt = None
if fix == None:
xmat_nt = None
else:
try:
fix_exp = ''
vec = fix.split('+')
for i in vec:
val = i.strip()
if val in class_vec:
fix_exp += 'C(' + val + ')'
else:
fix_exp += val
xmat_nt = dmatrix(fix_exp, data_df)
logging.info('The expression for fixed effect: ' + fix_exp)
except Exception as e:
logging.info(e + ': Check the fix effect expression.')
exit()
xmat_nt = csr_matrix(xmat_nt[:, 1:])
xmat = hstack([xmat_t, xmat_nt])
xmat = xmat.toarray()
max_id = max(data_df[id]) + 1
tmin = min(data_df[tpoint])
tmax = max(data_df[tpoint])
leg_lst = [
] # legendre polynomials for time dependent fixed SNP effects, save for each individuals
for i in range(1, max_id):
leg_lst.append(
leg_mt(data_df[data_df[id] == i][tpoint], tmax, tmin, forder))
tpoint_vec = sorted(set(data_df[tpoint]))
leg_tpoint_mat = leg_mt(np.array(tpoint_vec), tmax, tmin, forder)
leg_tpoint_accum = np.sum(leg_tpoint_mat, axis=0)
logging.info('***Read the kinship matrix***')
logging.info('Kinship file: ' + kin_file)
with open(kin_file) as fin:
row = []
col = []
kin = []
id_in_kin = {}
for line in fin:
arr = line.split()
id_in_kin[arr[0]] = 1
id_in_kin[arr[1]] = 1
if arr[0] not in code_dct[id]:
logging.info(arr[0] + ' is not in the kinship inversion file!')
exit()
if arr[1] not in code_dct[id]:
logging.info(arr[1], 'is not in the kinship inversion file!')
exit()
row.append(int(code_dct[id][arr[0]]))
col.append(int(code_dct[id][arr[1]]))
kin.append(float(arr[2]))
id_not_in_kin = list(set(code_dct[id].keys()) - set(id_in_kin.keys()))
if len(id_not_in_kin) != 0:
logging.info(
'The ID: {} in the data file is not in the kinship file!'.format(
' '.join(id_not_in_kin)))
exit()
kin = csr_matrix(
(np.array(kin), (np.array(row) - 1, np.array(col) - 1))).toarray()
kin = np.add(kin, kin.T)
kin[np.diag_indices_from(kin)] = 0.5 * np.diag(kin)
del row, col
gc.collect()
logging.info('***Build the dedign matrix for random effect***')
logging.info('Legendre order for additive effects: ' + str(aorder))
leg_add = leg(data_df[tpoint], aorder)
row = np.array(range(data_df.shape[0]))
col = np.array(data_df[id]) - 1
val = np.array([1.0] * data_df.shape[0])
add_mat = csr_matrix((val, (row, col)),
shape=(data_df.shape[0], kin.shape[0]))
zmat_add = []
for i in range(len(leg_add)):
zmat_add.append(add_mat.multiply(leg_add[i]))
logging.info('Legendre order for permanent environmental effect: ' +
str(porder))
leg_per = leg(data_df[tpoint], porder)
per_mat = csr_matrix((val, (row, col)))
zmat_per = []
for i in range(len(leg_per)):
zmat_per.append((per_mat.multiply(leg_per[i])))
del row, col, val
gc.collect()
zmat = [zmat_add, zmat_per]
y = data_df[trait].values.reshape(data_df.shape[0], 1)
# kin_inv = [kin_inv, sparse.eye(max(data_df[id]), format="csr")]
logging.info('***Prepare the merged Z matrix***')
eff_ind = [[0, xmat.shape[1]]] # the index for all effects [start end]
zmat_con_lst = [] # combined random matrix
for i in range(len(zmat)):
temp = [eff_ind[i][-1]]
zmat_con_lst.append(hstack(zmat[i]))
for j in range(len(zmat[i])):
temp.append(temp[-1] + zmat[i][j].shape[1])
eff_ind.append(temp)
logging.info('***Calculate the phenotypic (co)variance***')
add_cov = var_com.loc[var_com.loc[:, 'vari'] == 1, :]
row = np.array(add_cov['varij']) - 1
col = np.array(add_cov['varik']) - 1
val = add_cov['var_val']
add_cov = csr_matrix((val, (row, col))).toarray()
add_cov = add_cov + np.tril(add_cov, k=-1).T
per_cov = var_com.loc[var_com.loc[:, 'vari'] == 2, :]
row = np.array(per_cov['varij']) - 1
col = np.array(per_cov['varik']) - 1
val = per_cov['var_val']
per_cov = csr_matrix((val, (row, col))).toarray()
per_cov = per_cov + np.tril(per_cov, k=-1).T
res_var = np.array(var_com['var_val'])[-1]
vmat = zmat_con_lst[0].dot((zmat_con_lst[0].dot(np.kron(add_cov, kin))).T)
one_id = sparse.eye(zmat_con_lst[1].shape[1] / per_cov.shape[0])
vmat = vmat + zmat_con_lst[1].dot(
(zmat_con_lst[1].dot(sparse.kron(per_cov, one_id))).T)
vmat_diag = np.diag(vmat) + res_var
np.fill_diagonal(vmat, vmat_diag)
vmat = linalg.inv(vmat)
logging.info('***Read the snp data***')
snp_mat = read_plink(bed_file)
if np.any(np.isnan(snp_mat)):
logging.info('Missing genotypes are imputed with random genotypes.')
snp_mat = impute_geno(snp_mat)
num_id = snp_mat.shape[0]
num_snp = snp_mat.shape[1]
logging.info("There are {:d} individuals and {:d} SNPs.".format(
num_id, num_snp))
fam_df = pd.read_csv(bed_file + '.fam', sep='\s+', header=None)
id_geno = list(np.array(fam_df.iloc[:, 1], dtype=str))
id_order_index = []
for i in id_order:
id_order_index.append(id_geno.index(i))
if snp_lst is None:
snp_lst = range(num_snp)
snp_lst = list(snp_lst)
if min(snp_lst) < 0 or max(snp_lst) >= num_snp:
logging.info('The value in the snp list should be >= {} and < {}', 0,
num_snp)
exit()
snp_mat = snp_mat[id_order_index, :]
snp_mat = snp_mat[:, snp_lst]
logging.info(
'#####################################################################'
)
logging.info(
'###Start the fixed regression longitudinal GWAS for unbalance data###'
)
logging.info(
'#####################################################################'
)
chi_df = leg_lst[0].shape[1]
eff_vec = []
chi_vec = []
p_vec = []
p_min_vec = []
p_accum_vec = []
for i in tqdm(range(snp_mat.shape[1])):
snp_fix = list(map(lambda x, y: x * y, leg_lst, list(snp_mat[:, i])))
snp_fix = np.concatenate(snp_fix, axis=0)
snp_fix = np.concatenate((xmat, snp_fix), axis=1)
xv = np.dot(snp_fix.T, vmat)
xvx = np.dot(xv, snp_fix)
xvx = np.linalg.inv(xvx)
xvy = np.dot(xv, y)
b = np.dot(xvx, xvy)
eff = b[-chi_df:, -1]
eff_var = xvx[-chi_df:, -chi_df:]
chi_val = np.sum(np.dot(np.dot(eff.T, np.linalg.inv(eff_var)), eff))
p_val = chi2.sf(chi_val, chi_df)
eff_vec.append(b[-chi_df:, -1])
chi_vec.append(chi_val)
p_vec.append(p_val)
p_tpoint_vec = []
for k in range(leg_tpoint_mat.shape[0]):
eff_tpoint = np.sum(np.dot(leg_tpoint_mat[k, :], eff))
eff_var_tpoint = np.sum(
np.dot(leg_tpoint_mat[k, :],
np.dot(eff_var, leg_tpoint_mat[k, :])))
chi_tpoint = eff_tpoint * eff_tpoint / eff_var_tpoint
p_tpoint = chi2.sf(chi_tpoint, 1)
p_tpoint_vec.append(p_tpoint)
p_min_vec.append(min(p_tpoint_vec))
eff_accum = np.sum(np.dot(leg_tpoint_accum, eff))
eff_var_accum = np.sum(
np.dot(leg_tpoint_accum, np.dot(eff_var, leg_tpoint_accum)))
chi_accum = eff_accum * eff_accum / eff_var_accum
p_accum = chi2.sf(chi_accum, 1)
p_accum_vec.append(p_accum)
logging.info('Finish association analysis')
logging.info('***Output***')
snp_info_file = bed_file + '.bim'
snp_info = pd.read_csv(snp_info_file, sep='\s+', header=None)
res_df = snp_info.iloc[snp_lst, [0, 1, 3, 4, 5]]
res_df.columns = ['chro', 'snp_ID', 'pos', 'allele1', 'allele2']
res_df.loc[:, 'order'] = snp_lst
res_df = res_df.iloc[:, [5, 0, 1, 2, 3, 4]]
eff_vec = np.array(eff_vec)
for i in range(eff_vec.shape[1]):
col_ind = 'eff' + str(i)
res_df.loc[:, col_ind] = eff_vec[:, i]
res_df.loc[:, 'chi_val'] = chi_vec
res_df.loc[:, 'p_val'] = p_vec
res_df.loc[:, 'p_min'] = p_min_vec
res_df.loc[:, 'p_accum'] = p_accum_vec
out_file = prefix_outfile + '.res'
res_df.to_csv(out_file, sep=' ', index=False)
return res_df
def lindblad_dissipator(l):
return kron(l, l.conj()) - 0.5 *\
operator_to_superoperator(dag(l).dot(l), kind='anticommutator')
def laplop(m, n):
ddn = sp.spdiags(
np.ones(n) * np.array([[1, -2, 1]]).T, [-1, 0, 1], n, n)
ddm = sp.spdiags(
np.ones(m) * np.array([[1, -2, 1]]).T, [-1, 0, 1], m, m)
return sp.kron(ddm, sp.eye(n, n)) + sp.kron(sp.eye(m, m), ddn)
def compose(a, b):
return sparse.kron(a, b, format='bsr')
def BuildAKLT(self):
lat = self.Lat
for bond in range(0, lat.Number1neigh):
for i in range(0, self.Nsite):
j = lat.nn_[i, bond]
# print(j)
if i < j and j >= 0:
# Kxx1,2_ij
self.Kxx1Graph_[i, j] = lat.Kxx1
self.Kxx1Graph_[j, i] = lat.Kxx1
self.Kxx2Graph_[i, j] = lat.Kxx2
self.Kxx2Graph_[j, i] = lat.Kxx2
# Kyy1,2_ij
self.Kyy1Graph_[i, j] = lat.Kyy1
self.Kyy1Graph_[j, i] = lat.Kyy1
self.Kyy2Graph_[i, j] = lat.Kyy2
self.Kyy2Graph_[j, i] = lat.Kyy2
# Kzz1,2_ij
self.Kzz1Graph_[i, j] = lat.Kzz1
self.Kzz1Graph_[j, i] = lat.Kzz1
self.Kzz2Graph_[i, j] = lat.Kzz2
self.Kzz2Graph_[j, i] = lat.Kzz2
print("\nKxx1Graph_:")
matprint(self.Kxx1Graph_)
print("\nKyy1Graph_:")
matprint(self.Kyy1Graph_)
print("\nKzz1Graph_:")
matprint(self.Kzz1Graph_)
print("\nKxx2Graph_:")
matprint(self.Kxx2Graph_)
print("\nKyy2Graph_:")
matprint(self.Kyy2Graph_)
print("\nKzz2Graph_:")
matprint(self.Kzz2Graph_)
self.Kxx1Pair_, self.Kxx1coef_ = PairConstructor(
self.Kxx1Graph_, self.Nsite)
self.Kyy1Pair_, self.Kyy1coef_ = PairConstructor(
self.Kyy1Graph_, self.Nsite)
self.Kzz1Pair_, self.Kzz1coef_ = PairConstructor(
self.Kzz1Graph_, self.Nsite)
self.Kxx2Pair_, self.Kxx2coef_ = PairConstructor(
self.Kxx2Graph_, self.Nsite)
self.Kyy2Pair_, self.Kyy2coef_ = PairConstructor(
self.Kyy2Graph_, self.Nsite)
self.Kzz2Pair_, self.Kzz2coef_ = PairConstructor(
self.Kzz2Graph_, self.Nsite)
# ---------------------Build Hamiltonian as Sparse Matrix-------------------
print("[Hamiltonian.py] Building Hamiltonian as Sparse Matrix...")
Spins = Dofs("SpinOne")
if lat.Model == "TFIM":
Spins = Dofs("SpinHalf")
sx = Spins.Sx
sy = Spins.Sy
sz = Spins.Sz
print("-------------------------------------------", sx.shape)
Hamx1 = TwoSpinOps(self.Kxx1Pair_, self.Kxx1coef_, sx, sx, self.Nsite)
Hamy1 = TwoSpinOps(self.Kyy1Pair_, self.Kyy1coef_, sy, sy, self.Nsite)
Hamz1 = TwoSpinOps(self.Kzz1Pair_, self.Kzz1coef_, sz, sz, self.Nsite)
Hamxxxx2 = TwoSpinOps(self.Kxx2Pair_, self.Kxx2coef_, sx * sx, sx * sx,
self.Nsite)
Hamxxyy2 = TwoSpinOps(self.Kyy2Pair_, self.Kyy2coef_, sy * sy, sy * sy,
self.Nsite)
Hamxxzz2 = TwoSpinOps(self.Kzz2Pair_, self.Kzz2coef_, sz * sz, sz * sz,
self.Nsite)
Hamxy2 = TwoSpinOps(self.Kxx2Pair_, self.Kxx2coef_, sx * sy, sx * sy,
self.Nsite)
Hamxz2 = TwoSpinOps(self.Kyy2Pair_, self.Kyy2coef_, sx * sz, sx * sz,
self.Nsite)
Hamyx2 = TwoSpinOps(self.Kzz2Pair_, self.Kzz2coef_, sy * sx, sy * sx,
self.Nsite)
Hamyz2 = TwoSpinOps(self.Kxx2Pair_, self.Kxx2coef_, sy * sz, sy * sz,
self.Nsite)
Hamzx2 = TwoSpinOps(self.Kyy2Pair_, self.Kyy2coef_, sz * sx, sz * sx,
self.Nsite)
Hamzy2 = TwoSpinOps(self.Kzz2Pair_, self.Kzz2coef_, sz * sy, sz * sy,
self.Nsite)
Ham = Hamx1 + Hamy1 + Hamz1 + Hamxy2 + Hamxz2 + Hamyx2 + Hamyz2 + Hamzx2 + Hamzy2
Ham += Hamxxxx2 + Hamxxyy2 + Hamxxzz2
# --------------------------- Add external field -------------------------
hilsize = sx.shape[0]
for i in range(0, self.Nsite):
ida = sp.eye(hilsize**i)
idb = sp.eye(hilsize**(self.Nsite - i - 1))
Ham += sp.kron(ida, sp.kron(sx, idb)) * self.Hx
Ham += sp.kron(ida, sp.kron(sy, idb)) * self.Hy
Ham += sp.kron(ida, sp.kron(sz, idb)) * self.Hz
# if lat.Model == "AKLT":
Ham += sp.eye(Ham.shape[0]) * 2.0 / 3.0 * len(self.Kxx1coef_)
return Ham
def spmatkron(matlist):
return sps.csc_matrix(reduce(lambda A, B: sps.kron(A, B, 'csc'), matlist))
def mpc_increment(Ad_list, Bd_list, gd_list, x_tilda_vec, Xr, pred_x_tilda,
pred_del_u, Q, QN, R, N, xmin_tilda, xmax_tilda, del_umin,
del_umax):
"""
Incremental MPC
x_tilda_vec : [nx+nu, nx+nu]
Xr : [nx, N+1]
Q : [nx, nx]
R : [nu, nu]
"""
tic_mat = time.time()
# ========== Cast MPC problem to a QP: x = (x(0),x(1),...,x(N),u(0),...,u(N-1)) ==========
nx = Ad_list[0].shape[0]
nu = Bd_list[0].shape[1]
# Cast MPC problem to a QP:
# x = (x(0),x(1),...,x(N), u(0),...,u(N-1))
# Objective function
# C_tilda = [I, 0]
# Q_tilda = C_tilda.T * Q * C_tilta : (nx+nu, nx) * (nx, nx) * (nx, nx+nu) => (nx+nu, nx+nu)
C_tilda = sparse.hstack([sparse.eye(nx),
np.zeros([nx, nu])]) # (nx, nx+nu)
Q_tilda = C_tilda.transpose() * Q * C_tilda
Q_tilda_N = C_tilda.transpose() * QN * C_tilda
# - quadratic objective (P)
P = sparse.block_diag([
sparse.kron(sparse.eye(N), Q_tilda), # Q x (N+1) on diagonal
Q_tilda_N,
sparse.kron(sparse.eye(N), R), # R X (N) on diagonal
]).tocsc()
# - linear objective (q)
Q_C_tilda = Q * C_tilda
QN_C_tilda = QN * C_tilda
Q_C_tilda_trans = Q_C_tilda.transpose()
QN_C_tilda_trans = QN_C_tilda.transpose()
q = -Q_C_tilda_trans.dot(Xr[:, 0]) # index 0
for ii in range(N - 1):
q = np.hstack([q,
-Q_C_tilda_trans.dot(Xr[:, ii + 1])]) # index 1 ~ N-1
q = np.hstack([q, -QN_C_tilda_trans.dot(Xr[:, N]),
np.zeros(N * nu)]) # index N
# Augmentation for Incremental Control
Ad_sys = Ad_list[0]
Bd_sys = Bd_list[0]
Aug_A_sys = np.hstack([Ad_sys, Bd_sys])
Aug_A_increment = sparse.hstack(
[sparse.csr_matrix((nu, nx)),
sparse.eye(nu)])
Ad_tilda = sparse.vstack([Aug_A_sys, Aug_A_increment])
Bd_tilda = sparse.vstack([Bd_sys, sparse.eye(nu)])
Ax_Ad = sparse.csc_matrix(Ad_tilda)
Ax_diag = sparse.kron(sparse.eye(N + 1), -sparse.eye(nx + nu))
Bu_Bd = sparse.csc_matrix(Bd_tilda)
for i in range(N - 1):
Ad_sys = Ad_list[i + 1]
Bd_sys = Bd_list[i + 1]
Aug_A_sys = np.hstack([Ad_sys, Bd_sys])
Aug_A_increment = sparse.hstack(
[sparse.csr_matrix((nu, nx)),
sparse.eye(nu)])
Ad_tilda = sparse.vstack([Aug_A_sys, Aug_A_increment])
Bd_tilda = sparse.vstack([Bd_sys, sparse.eye(nu)])
Ax_Ad = sparse.block_diag([Ax_Ad, Ad_tilda])
Bu_Bd = sparse.block_diag([Bu_Bd, Bd_tilda])
Ax_Ad_top = sparse.kron(np.ones(N + 1), np.zeros((nx + nu, nx + nu)))
Ax_Ad_side = sparse.kron(np.ones((N, 1)), np.zeros((nx + nu, nx + nu)))
Ax = Ax_diag + sparse.vstack(
[Ax_Ad_top, sparse.hstack([Ax_Ad, Ax_Ad_side])])
Bu_Bd_top = sparse.kron(np.ones(N), np.zeros((nx + nu, nu)))
Bu = sparse.vstack([Bu_Bd_top, Bu_Bd])
Aeq = sparse.hstack([Ax, Bu])
# - Equality constraint (linear dynamics) : lower bound and upper bound
leq = -x_tilda_vec # later ueq == leq
for i in range(N):
gd_tilda = np.vstack([gd_list[i], np.zeros(
(nu, 1))]) # gd_tilda for augmented system
gd_tilda = np.squeeze(gd_tilda, axis=1) # from (N,1) to (N,)
leq = np.hstack([leq, -gd_tilda])
# leq = np.hstack([-x_tilda_vec, np.zeros(N*nx)])
ueq = leq
# Original Code
# ----- input and state constraints -----
Aineq = sparse.eye((N + 1) * (nx + nu) + N * nu)
lineq = np.hstack(
[np.kron(np.ones(N + 1), xmin_tilda),
np.kron(np.ones(N), del_umin)])
uineq = np.hstack(
[np.kron(np.ones(N + 1), xmax_tilda),
np.kron(np.ones(N), del_umax)])
# ----- OSQP constraints -----
A = sparse.vstack([Aeq, Aineq]).tocsc()
lb = np.hstack([leq, lineq])
ub = np.hstack([ueq, uineq])
print("matrix time :", time.time() - tic_mat)
# ==========Create an OSQP object and Setup workspace ==========
tic_solve = time.time()
prob = osqp.OSQP()
prob.setup(P, q, A, lb, ub, verbose=False, polish=False,
warm_start=False) # verbose: print output.
# Solve
res = prob.solve()
# Check solver status
if res.info.status != 'solved':
print('OSQP did not solve the problem!')
raise ValueError('OSQP did not solve the problem!')
print("solver time :", time.time() - tic_solve)
tic_pred = time.time()
# Predictive States and Actions
sol_state = res.x[:-N * nu]
sol_action = res.x[-N * nu:]
for ii in range((N + 1) * (nx + nu)):
if ii % (nx + nu) == 0:
pred_x_tilda[0, ii // (nx + nu)] = sol_state[ii] # X
elif ii % (nx + nu) == 1:
pred_x_tilda[1, ii // (nx + nu)] = sol_state[ii] # Y
elif ii % (nx + nu) == 2:
pred_x_tilda[2, ii // (nx + nu)] = sol_state[ii] # Vx
elif ii % (nx + nu) == 3:
pred_x_tilda[3, ii // (nx + nu)] = sol_state[ii] # Yaw
elif ii % (nx + nu) == 4:
pred_x_tilda[4, ii // (nx + nu)] = sol_state[ii] # Steer
else: # ii % (nx+nu) == 5:
pred_x_tilda[5, ii // (nx + nu)] = sol_state[ii] # accel_track
for jj in range((N) * nu):
if jj % nu == 0:
pred_del_u[0, jj // nu] = sol_action[jj]
else: # jj % nu == 1
pred_del_u[1, jj // nu] = sol_action[jj]
pred_del_u[:, -1] = pred_del_u[:, -2] # append last control
print("Parsing pred state action time :", time.time() - tic_pred)
return pred_x_tilda, pred_del_u
if bilayerfull :
sq2basTB, bas2sqTB = get_bilayer_bas(sq2bas, sq2bas)
#dd = [0]
EigeBLt = np.zeros((len(dd),eigv_k), dtype=float)
fig = plt.figure(1)
for ii in range(len(dd)):
print '# ii = ', ii
stime = time.time()
d = dd[ii]
VjjtIntL = FQHE_2DEG_Int_Interlayer(m, asp, d)
#print VjjtIntL
#break
row1, col1, dat1 = get_FQHE_Interlayer_MatEle(bas2sqTB, sq2basTB, bas2sq, sq2bas, bas2sq, sq2bas, VjjtIntL)
#HamBL = sps.kron(Ham, Ham, format='coo') #+ 0.0*sp.sparse.coo_matrix((dat1,(row1, col1)), shape=(numbas**2, numbas**2))
HamBL = sps.kron(np.eye(numbas), Hamff, format='coo')
HamBL += sps.kron(Hamff, np.eye(numbas), format='coo') + sp.sparse.coo_matrix((dat1,(row1, col1)), shape=(numbas**2, numbas**2))
EigeBL, EigfBL = eigsh(HamBL, k=eigv_k, which=mode1)
print sorted(EigeBL)
EigeBLt[ii,:] = np.real(sorted(EigeBL))-np.amin(EigeBL)
etime = time.time()
print 'get basis time =', etime - stime
#plt.clf()
plt.plot(dd*eigv_k, EigeBLt[:,0:5],'o')
plt.savefig('EigeBLt_third_'+str(m)+'_t.eps',format='eps')
np.savetxt('EigeBLt_third_'+str(m)+'_t.dat', EigeBLt)
plt.show()
def tensor(*args):
"""Calculates the tensor product of input operators.
Parameters
----------
args : array_like
``list`` or ``array`` of quantum objects for tensor product.
Returns
--------
obj : qobj
A composite quantum object.
Examples
--------
>>> tensor([sigmax(), sigmax()])
Quantum object: dims = [[2, 2], [2, 2]], shape = [4, 4], type = oper, isHerm = True
Qobj data =
[[ 0.+0.j 0.+0.j 0.+0.j 1.+0.j]
[ 0.+0.j 0.+0.j 1.+0.j 0.+0.j]
[ 0.+0.j 1.+0.j 0.+0.j 0.+0.j]
[ 1.+0.j 0.+0.j 0.+0.j 0.+0.j]]
"""
if not args:
raise TypeError("Requires at least one input argument")
num_args = len(args)
step = 0
for n in range(num_args):
if isinstance(args[n], Qobj):
qos = args[n]
if step == 0:
dat = qos.data
dim = qos.dims
shp = qos.shape
step = 1
else:
dat = sp.kron(dat, qos.data,
format='csr') #sparse Kronecker product
dim = [dim[0] + qos.dims[0],
dim[1] + qos.dims[1]] #append dimensions of Qobjs
shp = [dat.shape[0], dat.shape[1]] #new shape of matrix
elif isinstance(
args[n],
(list, ndarray)): #checks if input is list/array of Qobjs
qos = args[n]
items = len(qos) #number of inputs
if not all([
isinstance(k, Qobj) for k in qos
]): #raise error if one of the inputs is not a quantum object
raise TypeError("One of inputs is not a quantum object")
if items == 1: # if only one Qobj, do nothing
if step == 0:
dat = qos[0].data
dim = qos[0].dims
shp = qos[0].shape
step = 1
else:
dat = sp.kron(dat, qos[0].data,
format='csr') #sparse Kronecker product
dim = [dim[0] + qos[0].dims[0], dim[1] + qos[0].dims[1]
] #append dimensions of Qobjs
shp = [dat.shape[0], dat.shape[1]] #new shape of matrix
elif items != 1:
if step == 0:
dat = qos[0].data
dim = qos[0].dims
shp = qos[0].shape
step = 1
for k in range(items - 1): #cycle over all items
dat = sp.kron(dat, qos[k + 1].data,
format='csr') #sparse Kronecker product
dim = [
dim[0] + qos[k + 1].dims[0],
dim[1] + qos[k + 1].dims[1]
] #append dimensions of Qobjs
shp = [dat.shape[0], dat.shape[1]] #new shape of matrix
out = Qobj()
out.data = dat
out.dims = dim
out.shape = shp
if qutip.settings.auto_tidyup:
return Qobj(out).tidyup() #returns tidy Qobj
else:
return Qobj(out)
def to_linblad(self, gamma=1.):
l = self.data
return gamma * (kron(l, l.conj()) - \
operator_to_superoperator(dag(l).dot(l), type='anticommutator'))
def unbalance_emai(y,
xmat,
zmat,
kin,
init=None,
maxiter=30,
cc_par=1.0e-8,
cc_gra=1.0e-6,
em_weight_step=0.001):
num_var_pos = 1
for i in range(len(zmat)):
num_var_pos += len(zmat[i])
y_var = np.var(y) / num_var_pos
num_record = y.shape[0]
var_com = []
eff_ind = [[0, xmat.shape[1]]] # the index for all effects [start end]
zmat_con_lst = [] # combined random matrix
cov_dim = [] # the dim for covariance matrix
vari = []
varij = []
varik = []
i = 0
for i in range(len(zmat)):
temp = [eff_ind[i][-1]]
zmat_con_lst.append(hstack(zmat[i]))
cov_dim.append(len(zmat[i]))
for j in range(len(zmat[i])):
temp.append(temp[-1] + zmat[i][j].shape[1])
for k in range(j + 1):
vari.append(i + 1)
varij.append(j + 1)
varik.append(k + 1)
if j == k:
var_com.append(y_var)
else:
var_com.append(0.0)
eff_ind.append(temp)
var_com.append(y_var)
vari.append(i + 2)
varij.append(1)
varik.append(1)
if init is None:
var_com = np.array(var_com)
else:
if len(var_com) != len(init):
logging.info('ERROR: The length of initial variances should be' +
len(var_com))
exit()
else:
var_com = np.array(init)
var_com_update = np.array(var_com)
logging.info('***prepare the MME**')
zmat_con = hstack(zmat_con_lst) # design matrix for random effects
wmat = hstack([xmat, zmat_con]) # merged design matrix
cmat_pure = np.dot(wmat.T, wmat) # C matrix
rhs_pure = wmat.T.dot(y) # right hand
# em weight vector
if em_weight_step <= 0.0 or em_weight_step > 1.0:
logging.info(
'ERROR: The em weight step should be between 0 (not include) and 1 (include)'
)
exit()
iter_count = 0
cc_par_val = 1000.0
cc_gra_val = 1000.0
delta = 1000.0
logging.info("initial variances: " +
' '.join(np.array(var_com, dtype=str)))
covi_mat = pre_covi_mat(cov_dim, var_com)
if covi_mat is None:
logging.inf(
"ERROR: Initial variances is not positive define, please check!")
exit()
while iter_count < maxiter:
iter_count += 1
logging.info('***Start the iteration: ' + str(iter_count) + ' ***')
logging.info("Prepare the coefficient matrix")
cmat = (cmat_pure.multiply(1.0 / var_com[-1])).toarray()
for i in range(len(cov_dim)):
if isspmatrix(kin[i]):
temp = sparse.kron(covi_mat[i], kin[i])
temp = temp.toarray()
else:
temp = linalg.kron(covi_mat[i], kin[i])
cmat[eff_ind[i + 1][0]:eff_ind[i + 1][-1], \
eff_ind[i + 1][0]:eff_ind[i + 1][-1]] = \
np.add(cmat[eff_ind[i + 1][0]:eff_ind[i + 1][-1], \
eff_ind[i + 1][0]:eff_ind[i + 1][-1]], temp)
rhs_mat = np.divide(rhs_pure, var_com[-1])
cmati = linalg.inv(cmat)
eff = np.dot(cmati, rhs_mat)
e = y - xmat.dot(eff[:eff_ind[0][1], :]) - zmat_con.dot(
eff[eff_ind[0][1]:, :])
# first-order derivative
fd_mat = pre_fd_mat_x(cmati, kin, covi_mat, eff, eff_ind, e, cov_dim,
zmat_con_lst, wmat, num_record, var_com)
# AI matrix
ai_mat = pre_ai_mat(cmati, covi_mat, eff, eff_ind, e, cov_dim,
zmat_con_lst, wmat, var_com)
# EM matrix
em_mat = pre_em_mat(cov_dim, zmat_con_lst, num_record, var_com)
# Increase em weight to guarantee variances positive
gamma = -em_weight_step
while gamma < 1.0:
gamma = gamma + em_weight_step
if gamma >= 1.0:
gamma = 1.0
wemai_mat = (1 - gamma) * ai_mat + gamma * em_mat
delta = np.dot(linalg.inv(wemai_mat), fd_mat)
var_com_update = var_com + delta
covi_mat = pre_covi_mat(cov_dim, var_com_update)
if covi_mat is not None:
logging.info('EM weight value: ' + str(gamma))
break
logging.info('Updated variances: ' +
' '.join(np.array(var_com_update, dtype=str)))
if covi_mat is None:
logging.info("ERROR: Updated variances is not positive define!")
exit()
# Convergence criteria
cc_par_val = np.sum(pow(delta, 2)) / np.sum(pow(var_com_update, 2))
cc_par_val = np.sqrt(cc_par_val)
cc_gra_val = np.sqrt(np.sum(pow(fd_mat, 2))) / len(var_com)
var_com = var_com_update.copy()
logging.info("Change in parameters, Norm of gradient vector: " +
str(cc_par_val) + ', ' + str(cc_gra_val))
if cc_par_val < cc_par and cc_gra_val < cc_gra:
break
if cc_par_val < cc_par and cc_gra_val < cc_gra:
logging.info("Variances Converged")
else:
logging.info("Variances not Converged")
var_pd = {'vari': vari, "varij": varij, "varik": varik, "var_val": var_com}
var_pd = pd.DataFrame(var_pd,
columns=['vari', "varij", "varik", "var_val"])
return var_pd
def left(a):
if issparse(a):
idm = identity(a.toarray().shape[-1])
else:
idm = identity(a.shape[-1])
return kron(a, idm)
def configure_io(self):
"""
I/O creation is delayed until configure so that we can determine the shape and units for
the states.
"""
time_units = self.options['time_units']
num_disc_nodes = self.options['grid_data'].subset_num_nodes['state_disc']
num_col_nodes = self.options['grid_data'].subset_num_nodes['col']
state_options = self.options['state_options']
transcription = self.options['transcription']
self.add_input(name='dt_dstau', shape=(num_col_nodes,), units=time_units,
desc='For each node, the duration of its '
'segment in the integration variable')
self.xd_str = {}
self.fd_str = {}
self.xc_str = {}
self.xdotc_str = {}
for state_name, options in state_options.items():
shape = options['shape']
units = options['units']
rate_units = get_rate_units(units, time_units)
self.add_input(
name='state_disc:{0}'.format(state_name),
shape=(num_disc_nodes,) + shape,
desc='Values of state {0} at discretization nodes'.format(state_name),
units=units)
if transcription == 'gauss-lobatto':
self.add_input(
name='staterate_disc:{0}'.format(state_name),
shape=(num_disc_nodes,) + shape,
units=rate_units,
desc='EOM time derivative of state {0} at '
'discretization nodes'.format(state_name))
self.add_output(
name='state_col:{0}'.format(state_name),
shape=(num_col_nodes,) + shape, units=units,
desc='Interpolated values of state {0} at '
'collocation nodes'.format(state_name))
self.add_output(
name='staterate_col:{0}'.format(state_name),
shape=(num_col_nodes,) + shape,
units=rate_units,
desc='Interpolated rate of state {0} at collocation nodes'.format(state_name))
self.xd_str[state_name] = 'state_disc:{0}'.format(state_name)
self.fd_str[state_name] = 'staterate_disc:{0}'.format(state_name)
self.xc_str[state_name] = 'state_col:{0}'.format(state_name)
self.xdotc_str[state_name] = 'staterate_col:{0}'.format(state_name)
if transcription == 'gauss-lobatto':
Ai, Bi, Ad, Bd = self.options['grid_data'].phase_hermite_matrices('state_disc', 'col', sparse=True)
elif transcription == 'radau-ps':
Ai, Ad = self.options['grid_data'].phase_lagrange_matrices('state_disc', 'col', sparse=True)
Bi = Bd = sp.csr_matrix(np.zeros(shape=(num_col_nodes, num_disc_nodes)))
else:
raise ValueError('unhandled transcription type: '
'{0}'.format(self.options['transcription']))
self.matrices = {'Ai': Ai, 'Bi': Bi, 'Ad': Ad, 'Bd': Bd}
self.jacs = {'Ai': {}, 'Bi': {}, 'Ad': {}, 'Bd': {}}
self.sizes = {}
# self.num_col_nodes = num_col_nodes
# self.num_disc_nodes = num_disc_nodes
for name, options in state_options.items():
shape = options['shape']
size = np.prod(shape)
self.sizes[name] = size
for key in self.jacs:
# Each jacobian matrix has a form that is defined by the Kronecker product
# of the interpolation matrix and np.eye(size). Make sure to specify csc format
# here to avoid spurious zeros.
self.jacs[key][name] = sp.kron(sp.csr_matrix(self.matrices[key]),
sp.eye(size),
format='csc')
self.sizes[name] = size
#
# Partial of xdotc wrt dt_dstau
#
rs = np.arange(num_col_nodes * size, dtype=int)
cs = np.repeat(np.arange(num_col_nodes, dtype=int), size)
self.declare_partials(of=self.xdotc_str[name], wrt='dt_dstau',
rows=rs, cols=cs)
if transcription == 'gauss-lobatto':
self.declare_partials(
of=self.xc_str[name], wrt='dt_dstau',
rows=rs, cols=cs)
Ai_rows, Ai_cols, data = sp.find(self.jacs['Ai'][name])
self.declare_partials(of=self.xc_str[name], wrt=self.xd_str[name],
rows=Ai_rows, cols=Ai_cols, val=data)
Bi_rows, Bi_cols, _ = sp.find(self.jacs['Bi'][name])
self.declare_partials(of=self.xc_str[name], wrt=self.fd_str[name],
rows=Bi_rows, cols=Bi_cols)
Bd_rows, Bd_cols, data = sp.find(self.jacs['Bd'][name])
self.declare_partials(of=self.xdotc_str[name], wrt=self.fd_str[name],
rows=Bd_rows, cols=Bd_cols, val=data)
Ad_rows, Ad_cols, _ = sp.find(self.jacs['Ad'][name])
self.declare_partials(of=self.xdotc_str[name], wrt=self.xd_str[name],
rows=Ad_rows, cols=Ad_cols)
def radius(eps):
return approx_spectral_radius(kron(Hc, W).dot(eps) - kron(Hc2, D).dot(eps ** 2), pyamg=pyamg) - 1
def PhaseArray(i, k, theta):
if i == 0:
if k == 1:
return phase(theta)
return ss.kron(PhaseArray(i, k - 1, theta), identity, format='csr')
return ss.kron(identity, PhaseArray(i - 1, k - 1, theta), format='csr')
def random_model(shape, seed=None, anisotropy=None, its=100, bounds=None):
"""
Create a random model by convolving a kernel with a
uniformly distributed model.
Parameters
----------
shape: tuple
shape of the model.
seed: int
pick which model to produce, prints the seed if you don't choose.
anisotropy: numpy.ndarray
this is the (3 x n) blurring kernel that is used.
its: int
number of smoothing iterations
bounds: list
bounds on the model, len(list) == 2
Returns
-------
numpy.ndarray
M, the model
Examples
--------
.. plot::
:include-source:
import matplotlib.pyplot as plt
import discretize
plt.colorbar(plt.imshow(discretize.utils.random_model((50, 50), bounds=[-4, 0])))
plt.title('A very cool, yet completely random model.')
plt.show()
"""
if bounds is None:
bounds = [0, 1]
if seed is None:
seed = np.random.randint(1e3)
print('Using a seed of: ', seed)
if type(shape) in num_types:
shape = (shape, ) # make it a tuple for consistency
np.random.seed(seed)
mr = np.random.rand(*shape)
if anisotropy is None:
if len(shape) is 1:
smth = np.array([1, 10., 1], dtype=float)
elif len(shape) is 2:
smth = np.array([[1, 7, 1], [2, 10, 2], [1, 7, 1]], dtype=float)
elif len(shape) is 3:
kernal = np.array([1, 4, 1], dtype=float).reshape((1, 3))
smth = np.array(sp.kron(sp.kron(kernal, kernal.T).todense()[:], kernal).todense()).reshape((3, 3, 3))
else:
assert len(anisotropy.shape) is len(shape), 'Anisotropy must be the same shape.'
smth = np.array(anisotropy, dtype=float)
smth = smth/smth.sum() # normalize
mi = mr
for i in range(its):
mi = ndi.convolve(mi, smth)
# scale the model to live between the bounds.
mi = (mi - mi.min())/(mi.max()-mi.min()) # scaled between 0 and 1
mi = mi*(bounds[1]-bounds[0])+bounds[0]
return mi
# Nombre d'itération
iter_num = 21
# Fournit les coordonnées du centre du domaine
a = w / 2
#Demi-longueur du rectangle, qui restera constante
Longueur = 3 * a / 4
numpy.save(f"donnees_init.npy", np.array([w, iter_num, Longueur]))
## Création de la matrice d'incidence
x = eye(w - 1, w, 1) - eye(w - 1, w)
y = eye(w - 1, w, 1) - eye(w - 1, w)
B = vstack([kron(eye(w), x), kron(y, eye(w))])
B = torch.from_numpy(B.toarray())
## Etape de création du rectangle
# Construction du tableau initial
init_table = a * torch.ones((w, w))
y = w // 2
for i in range(w):
for j in range(w):
if abs(j - y) < Longueur:
init_table[i, j] = abs(i - y)
# Fonction d'activation
sigma = lambda x: 1 / (1 + torch.exp(-10 * x))
R = 0.1 * sparse.eye(1)
# Initial and reference states
x0 = np.array([0.1, 0.2]) # initial state
# Reference input and states
pref = 7.0
vref = 0
xref = np.array([pref, vref]) # reference state
# Prediction horizon
Np = 20
# Cast MPC problem to a QP: x = (x(0),x(1),...,x(N),u(0),...,u(N-1))
# - quadratic objective
P = sparse.block_diag(
[sparse.kron(sparse.eye(Np), Q), QN,
sparse.kron(sparse.eye(Np), R)]).tocsc()
# - linear objective
q = np.hstack(
[np.kron(np.ones(Np), -Q.dot(xref)), -QN.dot(xref),
np.zeros(Np * nu)])
# - linear dynamics
Ax = sparse.kron(sparse.eye(Np + 1), -sparse.eye(nx)) + sparse.kron(
sparse.eye(Np + 1, k=-1), Ad)
Bu = sparse.kron(sparse.vstack([sparse.csc_matrix((1, Np)),
sparse.eye(Np)]), Bd)
Aeq = sparse.hstack([Ax, Bu])
leq = np.hstack([-x0, np.zeros(Np * nx)])
ueq = leq # for equality constraints -> upper bound = lower bound!
# - input and state constraints
def HadmardArray(i, k):
if (i == 0):
if k == 1:
return hadmard
return ss.kron(HadmardArray(i, k - 1), identity, format='csr')
return ss.kron(identity, HadmardArray(i - 1, k - 1), format='csr')
if 0 <= i-j < m:
T[i,j] = b[i-j]
return T
# print(toeplitz([1,2,3], 10))
N = im_array.shape[0]
def gaussian1d(k_len = 5, sigma = 3):
return gaussian_kernel(k_len, sigma)[k_len//2,:]
curr_1d_kernel = gaussian1d(nitems, sigma)
# Gaussian 1D kernel as matrix
T = toeplitz(curr_1d_kernel, N)
row_mat = sparse.kron(sparse.eye(N), T)
col_mat = sparse.kron(T, sparse.eye(N+nitems-1))
G = col_mat.dot(row_mat)
flat_blurry_image = blurry_image.flatten()
def lst_sq(x, A=G, b=flat_blurry_image):
return linalg.norm(b - A.dot(x))**2
def lst_sq_grad(x, A=G, b=flat_blurry_image):
return 2*A.T.dot(A.dot(x) - b)
# optim_output = optimize.minimize(lst_sq, np.zeros(N**2), method='L-BFGS-B', jac=lst_sq_grad, options={'disp':True})
def scnnmat(dims, pot=0., hop=1., bcond='p', format='lil'):
"""Return Hamiltonian matrix of a simple dim-dimensional tight-binding
system with dimensions "dims" (tuple of positive integers of length dim),
site potentials "pot" (float or 1D-array of floats with length size =
prod(dims)), constant isotropic next-neighbor hopping "hop" (float) and
boundary conditions "bcond" (string consisting of characters "s", "p" and
"a"). Return matrix in LIL-sparse format.
bcond may be at most of length dim. In this way, each dimension can have
it's own boundary condition."""
# 2011-02-28
# check arguments
assert format \
in ['lil', 'dok', 'csr', 'csc', 'dia', 'coo', 'bsr', 'dense'], \
'unknown format. Must be one of lil, dok, coo, dia, csr, csc, bsr ' + \
'or dense'
if isiterable(dims):
dims = tuple(dims)
else:
dims = (dims,)
#dims = dims[::-1]
size = np.prod(dims, dtype=int)
dim = len(dims)
assert dim > 0, 'bad dimensions tuple: Must have at least one element'
# Check boundary condition string
assert len(bcond) <= dim, \
'bad boundary condition: %s. Number of given boundary conditions ' + \
'is greater than dimensionality of the system (%i)' % (bcond, dim)
assert len(bcond) > 0, \
'bad boundary condition: May not be empty string. At least one ' + \
'character (s, p or a) has to be given'
if len(bcond) < dim:
bcond += bcond[-1]*(dim-len(bcond))
# Method:
# 1. Build matrix of a system with dimensions dims[:-1] (recursive call of
# the function), set the dims[-1] blocks with it using kronecker product
# (scipy.sparse.kron)
# 2. Add the matrix elements of the remaining 1D-subsystem using setdiag
# That's it!
# Step 1
subdims = dims[:-1]
subsize = np.prod(subdims, dtype=int)
if subsize > 1:
# calculate submatrix recursevely
mat = spa.kron(spa.eye(dims[-1], dims[-1]),
scnnmat(subdims, hop=hop, bcond=bcond[:-1]),
format='lil')
else:
# initialize matrix
mat = spa.lil_matrix((size, size))
# Step 2
# If periodic or anti-periodic boundary conditions are given, set
# respective elements as well. Do this first, because they may be
# overwritten by the direct hoppings in the next step.
if bcond[-1] in ['p', 'a']:
if bcond[-1] == 'p':
bcondhoparray = np.ones((subsize))*(-hop)
else:
bcondhoparray = np.ones((subsize))*hop
mat.setdiag(bcondhoparray, size-subsize)
mat.setdiag(bcondhoparray, subsize-size)
elif bcond[-1] == 's':
# do not set anything
pass
else:
raise ValueError('bad boundary condition: %s. Expecting either "s" ' +
'(static), "p" (periodic) or "a" (antiperiodic)'
% bcond[-1])
# set off-diagonals with hopping
hoparray = np.ones((size-subsize))*(-hop)
mat.setdiag(hoparray, subsize)
mat.setdiag(hoparray, -subsize)
# set diagonal elements with potential
if isiterable(pot):
pot = np.array(pot)
assert len(pot.shape) == 1, \
'potentials have wrong shape. Must be 1D-array-like'
assert len(pot) == size, \
'wrong number of potentials: Expecting %i, but got %i' \
% (size, len(pot))
mat.setdiag(pot)
else:
if pot != 0.: # this step can be omitted if potentials are zero anyway
mat.setdiag(np.ones((size))*pot)
# convert matrix if needed
if format != 'lil':
mat = getattr(mat, 'to'+format)()
# return matrix
return mat
def ODW(Wo, Wd, transform='r', silence_warnings=True):
"""
Constructs an o*d by o*d origin-destination style spatial weight for o*d
flows using standard spatial weights on o origins and d destinations. Input
spatial weights must be binary or able to be sutiably transformed to binary.
Parameters
----------
Wo : W object for origin locations
o x o spatial weight object amongst o origins
Wd : W object for destination locations
d x d spatial weight object amongst d destinations
transform : Transformation for standardization of final OD spatial weight; default
is 'r' for row standardized
Returns
-------
W : spatial contiguity W object for assocations between flows
o*d x o*d spatial weight object amongst o*d flows between o
origins and d destinations
Examples
--------
>>> import libpysal.api as ps
>>> O = ps.lat2W(2,2)
>>> D = ps.lat2W(2,2)
>>> OD = ps.ODW(O,D)
>>> OD.weights[0]
[0.25, 0.25, 0.25, 0.25]
>>> OD.neighbors[0]
array([ 5, 6, 9, 10], dtype=int32)
>>> OD.full()[0][0]
array([0. , 0. , 0. , 0. , 0. , 0.25, 0.25, 0. , 0. , 0.25, 0.25,
0. , 0. , 0. , 0. , 0. ])
"""
if Wo.transform is not 'b':
try:
Wo.tranform = 'b'
except:
raise AttributeError(
'Wo is not binary and cannot be transformed to '
'binary. Wo must be binary or suitably transformed to binary.')
if Wd.transform is not 'b':
try:
Wd.tranform = 'b'
except:
raise AttributeError(
'Wd is not binary and cannot be transformed to '
'binary. Wd must be binary or suitably transformed to binary.')
Wo = Wo.sparse
Wo.eliminate_zeros()
Wd = Wd.sparse
Wd.eliminate_zeros()
Ww = kron(Wo, Wd, format='csr')
Ww.eliminate_zeros()
Ww = WSP(Ww).to_W(silence_warnings=silence_warnings)
Ww.transform = transform
return Ww
def geodesic(nTime,
nameFileD,
mub0,
mub1,
cCongestion,
eps,
Nit,
detailStudy=False,
verbose=False,
tol=1e-6):
"""Implementation of the algorithm for computing the geodesic in the Wasserstein space.
Arguments.
nTime: Number of discretization points in time
nameFileD: Name of the .off file where the triangle mesh is stored
mub0: initial probability distribution
mub1: final probability distribution
cCongestion: constant for the intensity of the regularization
(alpha in the article)
eps: regularization parameter for the linear system inversion
Nit: Number of iterations
detailStudy: True if the value of the objective functional (i.e. the
Lagrangian) and the residuals are computed at every time step (slow),
false if computed every 10 iterations (fast)
Output.
phi,mu,A,E,B: values of the relevant quantities in the interpolation,
cf. the article for more details (Note: E is the momentum, denoted by m
in the article) objectiveValue: evolution (in term of the number of
iterations of the ADMM) of the objective value, ie the Lagrangian
primalResidual,dualResidual: evolution (in term of the number of
iterations of the ADMM) of primal and dual residuals, cf the article for
details of their computation.
"""
startImport = time.time()
# Boolean value saying wether there is congestion or not
isCongestion = cCongestion >= 10**(-10)
if verbose:
print(15 * "-" + " Parameters for the computation of the geodesic " +
15 * "-")
print("Number of discretization points in time: {}".format(nTime))
print("Name of the mesh file: {}".format(nameFileD))
if isCongestion:
print("Congestion parameter: {}\n".format(cCongestion))
else:
print("No regularization\n")
# Time domain: staggered grid
xTimeS = np.linspace(0, 1, nTime + 1)
# Step Time
DeltaTime = xTimeS[1] - xTimeS[0]
# Time domain: centered grid
xTimeC = np.linspace(DeltaTime / 2, 1 - DeltaTime / 2, nTime)
# Domain D: call the routines
Vertices, Triangles, Edges = read_off.readOff(nameFileD)
areaTriangles, angleTriangles, baseFunction = geometricQuantities(
Vertices, Triangles, Edges)
gradientDMatrix, divergenceDMatrix, LaplacianDMatrix = geometricMatrices(
Vertices, Triangles, Edges, areaTriangles, angleTriangles,
baseFunction)
originTriangles, areaVertices, vertexTriangles = trianglesToVertices(
Vertices, Triangles, areaTriangles)
# Size of the domain D
nVertices = Vertices.shape[0]
nTriangles = Triangles.shape[0]
nEdges = Edges.shape[0]
# Vectorized quantities
# Enable to call in parallel on [0,1] x D something which is only defined on D.
# Vectorized arrays
areaVectorized = np.kron(np.kron(np.ones(6 * nTime), areaTriangles),
np.ones(3)).reshape(nTime, 2, 3, nTriangles, 3)
areaVerticesGlobal = np.kron(np.ones(nTime), areaVertices).reshape(
(nTime, nVertices))
areaVerticesGlobalStaggerred = np.kron(np.ones(nTime + 1),
areaVertices).reshape(
(nTime + 1, nVertices))
# Vectorized matrices
vertexTrianglesGlobal = scsp.kron(scsp.eye(nTime), vertexTriangles)
originTrianglesGlobal = scsp.kron(scsp.eye(nTime), originTriangles)
# Data structure with all the relevant informations. To be used as an argument of functions
geomDic = {
"nTime": nTime,
"DeltaTime": DeltaTime,
"Vertices": Vertices,
"Triangles": Triangles,
"Edges": Edges,
"areaTriangles": areaTriangles,
"gradientDMatrix": gradientDMatrix,
"divergenceDMatrix": divergenceDMatrix,
"LaplacianDMatrix": LaplacianDMatrix,
"originTriangles": originTriangles,
"areaVertices": areaVertices,
"vertexTriangles": vertexTriangles,
"nVertices": nVertices,
"nTriangles": nTriangles,
"nEdges": nEdges,
"areaVerticesGlobal": areaVerticesGlobal,
"areaVectorized": areaVectorized,
}
# Build the Laplacian matrix in space time and its inverse
LaplacianInvert = laplacian_inverse.buildLaplacianMatrix(geomDic, eps)
# Variable initialization
# Primal variable phi.
# Staggerred in Time, defined on the vertices of D
phi = np.zeros((nTime + 1, nVertices))
# Lagrange multiplier associated to mu.
# Centered in Time and lives on the vertices of D
mu = np.zeros((nTime, nVertices))
# Momentum E, lagrange mutliplier.
# Centered in Time, the second component is indicating on which side of
# the temporal it comes from. Third component indicates the origine of
# the triangle on which it is. Fourth component is the triangle. Last
# component corresponds to the fact that we are looking at a vector of R^3.
E = np.zeros((nTime, 2, 3, nTriangles, 3))
# Primal Variable A, corresponds to d_t phi.
# Same staggering pattern as mu
A = np.zeros((nTime, nVertices))
# Primal variable B, same pattern as E
B = np.zeros((nTime, 2, 3, nTriangles, 3))
# Lagrange multiplier associated to the congestion. If there is no
# congestion, the value of this parameter will always stay at 0.
lambdaC = np.zeros((nTime, nVertices))
# Making sure the boundary values are normalized
mub0 /= np.sum(mub0)
mub1 /= np.sum(mub1)
# Build the boundary term
BT = np.zeros((nTime + 1, nVertices))
BT[0, :] = -mub0
BT[-1, :] = mub1
# ADMM iterations
# Value of the "augmentation parameter" for the augmented Lagragian problem (update dynamically)
r = 1.
# Initialize the array which will contain the values of the objective functional
if detailStudy:
objectiveValue = np.zeros(3 * Nit)
else:
objectiveValue = np.zeros((Nit // 10))
# Initialize the arry which will contain the residuals
primalResidual = np.zeros(Nit)
dualResidual = np.zeros(Nit)
# Main Loop
for counterMain in range(Nit):
if verbose:
print(30 * "-" + " Iteration " + str(counterMain + 1) + " " +
30 * "-")
if detailStudy:
objectiveValue[3 * counterMain] = objectiveFunctional(
phi, mu, A, E, B, lambdaC, BT, geomDic, r, cCongestion,
isCongestion)
elif (counterMain % 10) == 0:
objectiveValue[counterMain // 10] = objectiveFunctional(
phi, mu, A, E, B, lambdaC, BT, geomDic, r, cCongestion,
isCongestion)
# Laplace problem
startLaplace = time.time()
# Build the RHS
RHS = np.zeros((nTime + 1, nVertices))
RHS -= BT * nTime
RHS -= gradATime(mu, geomDic)
RHS += np.multiply(r * gradATime(A + lambdaC, geomDic),
areaVerticesGlobalStaggerred / 3)
# We take the adjoint wrt tp the scalar product weighted by areas, hence the multiplication by areaVectorized
RHS -= divergenceD(E, geomDic)
RHS += r * divergenceD(np.multiply(B, areaVectorized), geomDic)
# Solve the system
phi = 1. / r * LaplacianInvert(RHS)
endLaplace = time.time()
if verbose:
print("Solving the Laplace system: {}s.".format(
round(endLaplace - startLaplace, 2)))
if detailStudy:
objectiveValue[3 * counterMain + 1] = objectiveFunctional(
phi, mu, A, E, B, lambdaC, BT, geomDic, r, cCongestion,
isCongestion)
# Projection over a convex set ---------------------------------------------------------
# It projects on the set A + 1/2 |B|^2 <= 0. We reduce to a 1D projection, then use a Newton method with a fixed number of iteration.
startProj = time.time()
# Computing the derivatives of phi
dTphi = gradTime(phi, geomDic)
dDphi = gradientD(phi, geomDic)
# Computing what there is to project
toProjectA = dTphi + 3. / r * np.divide(mu, areaVerticesGlobal)
toProjectB = dDphi + 1. / r * np.divide(E, areaVectorized)
# bSquaredArray will contain
# (sum_{a ~ v} |a| |B_{a,v}|**2) / (4*sum_{a ~ v} |a|)
# for each vertex v
bSquaredArray = np.zeros((nTime, nVertices))
# square and sum to compute in account the eulcidean norm and the temporal average
squareAux = np.sum(np.square(toProjectB), axis=(1, 4))
# average wrt triangles
bSquaredArray = originTrianglesGlobal.dot(
squareAux.reshape(nTime * 3 * nTriangles)).reshape(
(nTime, nVertices))
# divide by the sum of the areas of the neighboring triangles
bSquaredArray = np.divide(bSquaredArray, 4 * areaVerticesGlobal)
# Value of the objective functional. For the points not in the convex, we want it to vanish.
projObjective = toProjectA + bSquaredArray
# projDiscriminating is 1 is the point needs to be projected, 0 if it is already in the convex
projDiscriminating = (np.greater(
projObjective, 10**(-16) * np.ones(
(nTime, nVertices)))).astype(float)
# Newton method iteration
# Value of the Lagrange multiplier. Initialized at 0, not updated if already in the convex set
xProj = np.zeros((nTime, nVertices))
counterProj = 0
# Newton's loop
while np.max(projObjective) > 10**(-10) and counterProj < 20:
# Objective functional
projObjective = (toProjectA + 6 * (1. + cCongestion * r) * xProj +
np.divide(bSquaredArray, np.square(1 - xProj)))
# Derivative of the ojective functional
dProjObjective = 6 * (1. + cCongestion * r) - 2. * np.divide(
bSquaredArray, np.power(xProj - 1, 3))
# Update of xProj
xProj -= np.divide(np.multiply(projDiscriminating, projObjective),
dProjObjective)
counterProj += 1
# Update of A
A = toProjectA + 6 * (1. + cCongestion * r) * xProj
# Update of lambda
lambdaC = -6 * cCongestion * r * xProj
# Transfer xProj, which is defined on vertices into something which is defined on triangles
xProjTriangles = np.kron(
vertexTrianglesGlobal.dot(xProj.reshape(
nTime * nVertices)).reshape((nTime, 3, nTriangles)),
np.ones(3),
).reshape((nTime, 3, nTriangles, 3))
# Update of B
B[:, 0, :, :, :] = np.divide(toProjectB[:, 0, :, :, :],
1. - xProjTriangles)
B[:, 1, :, :, :] = np.divide(toProjectB[:, 1, :, :, :],
1. - xProjTriangles)
# Print the info
endProj = time.time()
if verbose:
print("Pointwise projection: {}s.".format(
str(round(endProj - startProj, 2))))
print("{} iterations needed; error committed: {}.".format(
counterProj, np.max(projObjective)))
if detailStudy:
objectiveValue[3 * counterMain + 2] = objectiveFunctional(
phi, mu, A, E, B, lambdaC, BT, geomDic, r, cCongestion,
isCongestion)
# Gradient descent in (E,muTilde), i.e. in the dual
# No need to recompute the derivatives of phi
# Update for mu
mu -= r / 3 * np.multiply(areaVerticesGlobal, A + lambdaC - dTphi)
# Update for E
E -= r * np.multiply(areaVectorized, B - dDphi)
# Compute the residuals
# For the primal residual, just what was updated in the dual
primalResidual[counterMain] = sqrt((scalarProductFun(
A + lambdaC - dTphi,
np.multiply(A + lambdaC - dTphi, areaVerticesGlobal / 3.0),
geomDic,
) + scalarProductTriangles(B - dDphi, B - dDphi, geomDic)) /
np.sum(areaTriangles))
# For the residual, take the RHS of the Laplace system and conserve only
# BT and the dual variables mu, E
dualResidualAux = np.zeros((nTime + 1, nVertices))
dualResidualAux += BT / DeltaTime
dualResidualAux += gradATime(mu, geomDic)
dualResidualAux += divergenceD(E, geomDic)
dualResidual[counterMain] = r * sqrt(
scalarProductFun(
dualResidualAux,
np.multiply(dualResidualAux,
areaVerticesGlobalStaggerred / 3.0),
geomDic,
) / np.sum(areaTriangles))
# Break early if residuals are small
if primalResidual[counterMain] < tol and dualResidual[
counterMain] < tol:
break
# Update the parameter r
# cf. Boyd et al. for an explanantion of the rule
if primalResidual[counterMain] >= 10 * dualResidual[counterMain]:
r *= 2
elif 10 * primalResidual[counterMain] <= dualResidual[counterMain]:
r /= 2
# Printing some results
if verbose:
if detailStudy:
print("Maximizing in phi, should go up: {}".format(
objectiveValue[3 * counterMain + 1] -
objectiveValue[3 * counterMain]))
print("Maximizing in A,B, should go up: {}".format(
objectiveValue[3 * counterMain + 2] -
objectiveValue[3 * counterMain + 1]))
if counterMain >= 1:
print("Dual update: should go down: {}".format(
objectiveValue[3 * counterMain] -
objectiveValue[3 * counterMain - 1]))
print("Values of phi: {}/{}\n".format(np.max(phi), np.min(phi)))
print("Values of A: {}/{}\n".format(np.max(A), np.min(A)))
print("Values of mu: {}/{}\n".format(np.max(mu), np.min(mu)))
print("Values of E: {}/{}\n".format(np.max(E), np.min(E)))
if isCongestion:
print("Congestion")
print(
scalarProductFun(lambdaC, mu, geomDic) - 1 /
(2. * cCongestion) * scalarProductFun(
lambdaC, np.multiply(lambdaC, areaVerticesGlobal /
3.), geomDic))
print(cCongestion / 2. *
np.sum(np.divide(np.square(mu), 1 / 3. * areaVertices)) /
nTime)
# Print some informations at the end of the loop
if verbose:
print("Final value of the augmenting parameter: {}".format(r))
# Integral of mu wrt space (depends on time), should sum up to 1.
intMu = np.sum(mu, axis=(-1))
print("Minimal and maximal value of int mu: {}/{}".format(
np.min(intMu), np.max(intMu)))
print("Maximal and minimal value of mu: {}/{}".format(
np.min(mu), np.max(mu)))
dTphi = gradTime(phi, geomDic)
dDphi = gradientD(phi, geomDic)
print("Agreement between nabla_t,D and (A,B)")
print(np.max(np.abs(dTphi - A)))
print(np.max(np.abs(dDphi - B)))
endProgramm = time.time()
print("Primal/dual residuals at end: {}/{}".format(
primalResidual[counterMain], dualResidual[counterMain]))
print("Congestion norm: {}".format(
np.linalg.norm(lambdaC - cCongestion * (mu / (areaVertices / 3)))))
print("Objective value at end: {}".format(objectiveValue[counterMain //
10]))
print("Total number of iterations: {}".format(counterMain))
print("Total time taken by the computation of the geodesic: {}".format(
round(endProgramm - startImport, 2)))
return phi, mu, A, E, B, objectiveValue, primalResidual, dualResidual
data = np.tile([-1,1],length)
row = np.arange(length).repeat(2)
col=[]
j=0
for track in moving:
end = j+track.shape[0]
col.append(np.arange(j,end).repeat(2)[1:-1])
j = end
col = np.concatenate(col)
M = sparse.csr_matrix((data,(row,col)),(length,con_moving.shape[0]))
''' Get G '''
# G = sparse.diags([1,1,1,lamb])
MG = alpha*sparse.kron(M,sparse.diags([1,1,1,lamb])).tocsr()
''' Get Zeros '''
zer = np.zeros((MG.shape[0],3))
A = sparse.vstack([MG,WD])
B = np.vstack([zer,WU])
X = np.zeros((A.shape[1],3))
acon = np.zeros((3))
for i in range(3):
result = np.array(lsqr(A,B[:,i]))
X[:,i] = result[0]
acon[i] = result[6]
print(acon)
def BuildHeisenberg(self):
lat = self.Lat
for bond in range(0, lat.Number1neigh):
for i in range(0, self.Nsite):
j = lat.nn_[i, bond]
# print(j)
if i < j and j >= 0:
# Kxx_ij * S_i^x S_j^x
self.KxxGraph_[i, j] = self.Kxx
self.KxxGraph_[j, i] = self.Kxx
# Kyy_ij * S_i^y S_j^y
self.KyyGraph_[i, j] = self.Kyy
self.KyyGraph_[j, i] = self.Kyy
# Kzz_ij * S_i^z S_j^z
self.KzzGraph_[i, j] = self.Kzz
self.KzzGraph_[j, i] = self.Kzz
print("\nKxxGraph_:")
matprint(self.KxxGraph_)
print("\nKyyGraph_:")
matprint(self.KyyGraph_)
print("\nKzzGraph_:")
matprint(self.KzzGraph_)
# matprint(self.KxxGraph_-self.KzzGraph_); matprint(self.KxxGraph_-self.KyyGraph_)
self.KxxPair_, self.Kxxcoef_ = PairConstructor(self.KxxGraph_,
self.Nsite)
self.KyyPair_, self.Kyycoef_ = PairConstructor(self.KyyGraph_,
self.Nsite)
self.KzzPair_, self.Kzzcoef_ = PairConstructor(self.KzzGraph_,
self.Nsite)
# print(self.KzzPair_)
# print(self.Kzzcoef_)
# ---------------------Build Hamiltonian as Sparse Matrix-------------------
print("[Hamiltonian.py] Building Hamiltonian as Sparse Matrix...")
Spins = Dofs("SpinHalf")
sx = Spins.Sx
sy = Spins.Sy
sz = Spins.Sz
Hamx = TwoSpinOps(self.KxxPair_, self.Kxxcoef_, sx, sx, self.Nsite)
Hamy = TwoSpinOps(self.KyyPair_, self.Kyycoef_, sy, sy, self.Nsite)
Hamz = TwoSpinOps(self.KzzPair_, self.Kzzcoef_, sz, sz, self.Nsite)
Ham = Hamx + Hamy + Hamz
# --------------------------- Add external field -------------------------
for i in range(0, self.Nsite):
ida = sp.eye(2**i)
idb = sp.eye(2**(self.Nsite - i - 1))
Ham += sp.kron(ida, sp.kron(sx, idb)) * self.Hx
Ham += sp.kron(ida, sp.kron(sy, idb)) * self.Hy
Ham += sp.kron(ida, sp.kron(sz, idb)) * self.Hz
return Ham