def setupCurrentOperator(T, J, eta):
x = eta * (np.diag(np.sqrt(np.arange(
(prms.maxPhotonNumber - 1)) + 1), -1) +
np.diag(np.sqrt(np.arange((prms.maxPhotonNumber - 1)) + 1), +1))
sinX = sciLin.sinm(x)
cosX = sciLin.cosm(x)
return cosX * J - sinX * T
def expectCosA(eta):
gs = arbOrder.findGS(eta, 3)
gsJ = eF.J(gs)
gsT = eF.T(gs)
ptGS = phState.findPhotonGS([gsT, gsJ], eta, 3)
x = setUpA(eta)
cosX = sciLin.cosm(x)
return np.dot(np.conj(ptGS), np.dot(cosX, ptGS))
def test_cosm():
"""
Test Qobj: cosm
"""
A = rand_herm(5)
B = A.cosm().full()
C = la.cosm(A.full())
assert_(np.all((B-C)< 1e-14))
def test_cosm():
"""
Test Qobj: cosm
"""
A = rand_herm(5)
B = A.cosm().full()
C = la.cosm(A.full())
assert_(np.all((B-C)< 1e-14))
def expectationCos(eta):
phGS = getPhGS(eta)
#phGS = coherentState.getSqueezedState(eta, gsT)
x = eta * (np.diag(np.sqrt(np.arange(
(prms.maxPhotonNumber - 1)) + 1), -1) +
np.diag(np.sqrt(np.arange((prms.maxPhotonNumber - 1)) + 1), +1))
cosX = sciLin.cosm(x)
cosExpectation = np.dot(np.transpose(np.conj(phGS)), np.dot(cosX, phGS))
return cosExpectation
def gfNumPointTLesser(kVec, tVec, eta):
phGS = getPhGS(eta)
#phGS = coherentState.getCoherentStateForN(3.)
H = getH(eta)
gk = -2. * prms.t * np.sin(kVec)
eK = 2. * prms.t * np.cos(kVec)
x = eta * (np.diag(np.sqrt(np.arange(
(prms.maxPhotonNumber - 1)) + 1), -1) +
np.diag(np.sqrt(np.arange((prms.maxPhotonNumber - 1)) + 1), +1))
sinX = sciLin.sinm(x)
cosX = sciLin.cosm(x)
#iHt = 1j * H[None, :, :] * tVec[:, None, None]
#iHtSinCos = - 1j * H[None, None, :, :] * tVec[None, :, None, None] \
# - 1j * gk[:, None, None, None] * sinX[None, None, :, :] * tVec[None, :, None, None] \
# - 1j * eK[:, None, None, None] * cosX[None, None, :, :] * tVec[None, :, None, None]
hEvals, hEvecs = np.linalg.eigh(H)
HtSinCosK = H[None, :, :] \
- gk[:, None, None] * sinX[None, :, :] \
- eK[:, None, None] * cosX[None, :, :]
eValsK, eVecsK = np.linalg.eigh(HtSinCosK)
GF = np.zeros((len(kVec), len(tVec)), dtype='complex')
for tInd, t in enumerate(tVec):
expiHt = np.dot(
hEvecs,
np.dot(np.diag(np.exp(-1j * hEvals * t)),
np.transpose(np.conj(hEvecs))))
for kInd, k in enumerate(kVec):
expiHSinCost = np.dot(
eVecsK[kInd, :, :],
np.dot(np.diag(np.exp(1j * eValsK[kInd, :, ] * t)),
np.transpose(np.conj(eVecsK[kInd, :, :]))))
prod1 = np.dot(expiHt, phGS)
prod2 = np.dot(expiHSinCost, prod1)
#prod1 = np.dot( sciLin.expm(iHtSinCos[kInd, tInd, :, :]), phGS)
#prod2 = np.dot( sciLin.expm(iHt[tInd, :, :]), prod1)
res = np.dot(np.conj(phGS), prod2)
GF[kInd, tInd] = res
return -1j * GF
def gfPointTGS(kVec, tRel, tAv, eta):
phState = getPhGS(eta)
H = getH(eta)
gk = -2. * prms.t * np.sin(kVec)
eK = 2. * prms.t * np.cos(kVec)
x = eta * (np.diag(np.sqrt(np.arange(
(prms.maxPhotonNumber - 1)) + 1), -1) +
np.diag(np.sqrt(np.arange((prms.maxPhotonNumber - 1)) + 1), +1))
sinX = sciLin.sinm(x)
cosX = sciLin.cosm(x)
#iHTRelMTAv, iHTRelPTAv, iHtSinCosTRel = setUpMatricies(H, cosX, eK, gk, sinX, tAv, tRel)
HSinCos = H[None, :, :] + gk[:, None, None] * sinX[
None, :, :] + eK[:, None, None] * cosX[None, :, :]
# expiHt, expiHtDash, exptRel = setUpExponentialMatricies(iHTRelMTAv, iHTRelPTAv, iHtSinCosTRel, kVec, tAv, tRel)
expiHt, expiHtDash, exptRel = setUpExponentialMatricies(
H, HSinCos, kVec, tRel, tAv)
GF = evaluateBraKet(expiHt, expiHtDash, exptRel, kVec, phState, tAv, tRel)
return -1j * GF
def gfPointTCoh(kVec, tRel, tAv, eta, N):
phState = coherentState.getCoherentStateForN(N)
#phState = coherentState.getSqueezedStateFor(N)
H = getH(eta)
print("kVec-Val = {}".format(kVec[0] / np.pi))
gk = -2. * prms.t * np.sin(kVec)
eK = 2. * prms.t * np.cos(kVec)
x = eta * (np.diag(np.sqrt(np.arange(
(prms.maxPhotonNumber - 1)) + 1), -1) +
np.diag(np.sqrt(np.arange((prms.maxPhotonNumber - 1)) + 1), +1))
sinX = sciLin.sinm(x)
cosX = sciLin.cosm(x)
timeStart = time.time()
# iHTRelMTAv, iHTRelPTAv, iHtSinCosTRel = setUpMatricies(H, cosX, eK, gk, sinX, tAv, tRel)
HSinCos = H[None, :, :] + gk[:, None, None] * sinX[
None, :, :] + eK[:, None, None] * cosX[None, :, :]
timeStop = time.time()
print("setUpMatricies take: {}".format(timeStop - timeStart))
timeStart = time.time()
# expiHt, expiHtDash, exptRel = setUpExponentialMatricies(iHTRelMTAv, iHTRelPTAv, iHtSinCosTRel, kVec, tAv, tRel)
expiHt, expiHtDash, exptRel = setUpExponentialMatricies(
H, HSinCos, kVec, tRel, tAv)
timeStop = time.time()
print("setUpExponentialMatricies take: {}".format(timeStop - timeStart))
timeStart = time.time()
GF = evaluateBraKet(expiHt, expiHtDash, exptRel, kVec, phState, tAv, tRel)
timeStop = time.time()
print("evaluateBraKet take: {}".format(timeStop - timeStart))
return -1j * GF
def gfPointTCohTurned(kPoint, tRel, tAv, eta, N):
#phState = coherentState.getCoherentStateForN(N)
phState = coherentState.getShiftedGS(eta, N)
H = getH(eta)
timeStart = time.time()
#iHTRelMTAv, iHTRelPTAv, iHtSinCosTRel = setUpMatricies(kPoint, H, tAv, tRel, eta)
gk = -2. * prms.t * np.sin(kPoint)
eK = 2. * prms.t * np.cos(kPoint)
x = eta * (np.diag(np.sqrt(np.arange(
(prms.maxPhotonNumber - 1)) + 1), -1) +
np.diag(np.sqrt(np.arange((prms.maxPhotonNumber - 1)) + 1), +1))
sinX = sciLin.sinm(x)
cosX = sciLin.cosm(x)
HSinCos = H - gk * sinX - eK * cosX
timeStop = time.time()
print("setUpMatricies take: {}".format(timeStop - timeStart))
timeStart = time.time()
expiHt, expiHtDash, exptRel = setUpExponentialMatricies(
H, HSinCos, tRel, tAv)
timeStop = time.time()
print("setUpExponentialMatricies take: {}".format(timeStop - timeStart))
timeStart = time.time()
GF = evaluateBraKetTurned(expiHt, expiHtDash, exptRel, kPoint, phState,
tAv, tRel)
timeStop = time.time()
print("evaluateBraKet take: {}".format(timeStop - timeStart))
return +1j * GF
def gfPointTGS(kPoint, tRel, tAv, eta):
phState = getPhGS(eta)
H = getH(eta)
gk = -2. * prms.t * np.sin(kPoint)
eK = 2. * prms.t * np.cos(kPoint)
x = eta * (np.diag(np.sqrt(np.arange(
(prms.maxPhotonNumber - 1)) + 1), -1) +
np.diag(np.sqrt(np.arange((prms.maxPhotonNumber - 1)) + 1), +1))
sinX = sciLin.sinm(x)
cosX = sciLin.cosm(x)
#iHTRelMTAv, iHTRelPTAv, iHtSinCosTRel = setUpMatricies(kPoint, H, tAv, tRel, eta)
HSinCos = H + gk * sinX + eK * cosX
expiHt, expiHtDash, exptRel = setUpExponentialMatricies(
H, HSinCos, tRel, tAv)
#expiHt, expiHtDash, exptRel = setUpExponentialMatricies(iHTRelMTAv, iHTRelPTAv, iHtSinCosTRel, tAv, tRel)
GF = evaluateBraKet(expiHt, expiHtDash, exptRel, kPoint, phState, tAv,
tRel)
return -1j * GF
def calcCosAdaggerA(eta):
aDaggerA = eta * calcAplusAdagger()
return cosm(aDaggerA)[0:prms.maxPhotonNumber, 0:prms.maxPhotonNumber]
#Importamos la librería import scipy.linalg as ln import numpy as np #Creamos una matriz aleatoria de 3x3 ran = np.random.rand(3,3) #Imprimimos la matriz generada print ran #Imprimimos la inversa de la matriz original print "\n" print ln.inv(ran) #Imprimimos el seno de la matriz original print "\n" print ln.sinm(ran) #Imprimimos el coseno print "\n" print ln.cosm(ran) #Imprimimos la tangente print "\n" print ln.tanm(ran) #Imprimimos el logaritmo print "\n" print ln.logm(ran)
from scipy import sparse,linalg
import scipy
import numpy as np
np_matrix=np.matrix(np.random.random((5,5)))
np_vector=np.array([1,2,1])
np_iden=np.eye(3,k=0)
# np_iden[0][0]=2
# np_iden[1][1]=2
# np_iden[2][0]=2
print('np.eye',np_iden)
print('sparse.csr_matrix',sparse.csr_matrix(np_iden))
print('sparse.csc_matrix',sparse.csc_matrix(np_iden))
print('sparse.dok_matrix',sparse.dok_matrix(np_iden))
print('sparse.bsr_matrix',sparse.bsr_matrix(np_iden))
print('sparse.coo_matrix',sparse.coo_matrix(np_iden))
print('sparse.lil_matrix',sparse.lil_matrix(np_iden))
print('sparse.dia_matrix',sparse.dia_matrix(np_iden))
print('linalg.expm',linalg.expm(np_iden))
# print('linalg.expm2',sparse.linalg.expm2(np_iden))
# print('linalg.expm3',linalg.expm3(np_iden))
print('linalg.cosm',linalg.cosm(np_iden))
print('linalg.sinm',linalg.sinm(np_iden))
print('linalg.norm',linalg.norm(np_iden))
print('linalg.det',linalg.det(np_iden))
# print('sparse.linalg.spsolve',sparse.linalg.spsolve(np_iden,np_iden.T))
print('sparse.linalg.eig',linalg.eigvals(np_iden))
print('linallg.svd',linalg.svd(np_iden))
def gsEffectiveKineticEnergy(eta):
gsT = -2. / np.pi * prms.chainLength
ptState = getSqueezedState(eta, gsT)
cosOp = sciLin.cosm(eta * (aDagOp() + aOp()))
kineticE = gsT * np.dot(np.conj(ptState), np.dot(cosOp, ptState))
return kineticE / prms.chainLength
