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 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