def vertExpand(self,UnX,wS,wSX,wSY,AC): beTa=self.beTa NW=self.NW wB=self.wB NLmax=self.NLmax wMidI=self.wMidI uShape=wS.shape wS=np.reshape(wS,wS.size) wSX=np.reshape(wSX,wSX.size) wSY=np.reshape(wSY,wSY.size) nPoints=len(wS) UnXi=np.swapaxes(UnX,1,2) UnXi=np.concatenate((np.conj(UnX[:0:-1,:,:]),UnX),axis=0) UnXiF=auxF.linInterp(wMidI,UnXi,wS) zSX=auxF.forMap(wSX/np.sqrt(AC**2+1),1.0) zSY=auxF.forMap(wSY/np.sqrt(AC**2+1),1.0) lTempXN=np.zeros((nPoints,1,NW)) lTempYN=np.zeros((nPoints,NW,1)) for i in range(NW): lTempXN[:,0,i]=auxF.freqExpansion(zSX,2*i) lTempYN[:,i,0]=auxF.freqExpansion(zSY,2*i) UnE=np.zeros(len(wS),dtype=np.complex_) UnE=np.squeeze(np.matmul(lTempXN,np.matmul(UnXiF,lTempYN))) return np.reshape(UnE,uShape)
def _expandChannel(self,wS,wSX,wSY,AC,chnL): if chnL is 'PP': UnX = self.UnPP elif chnL is 'PH': UnX = self.UnPH elif chnL is 'PHE': UnX = self.UnPHE beTa=self.beTa NW=self.NW wB=self.wB NLmax=self.NLmax nPoints=len(wS) wMidI=self.wMidI UnXi=np.swapaxes(UnX,1,2) UnXi=np.concatenate((np.conj(UnX[:0:-1,:,:]),UnX),axis=0) UnXiF=auxF.linInterp(wMidI,UnXi,wS) zSX=auxF.forMap(wSX/np.sqrt(AC**2+1),1.0) zSY=auxF.forMap(wSY/np.sqrt(AC**2+1),1.0) lTempXN=np.zeros((nPoints,1,NW)) lTempYN=np.zeros((nPoints,NW,1)) for i in range(NW): lTempXN[:,0,i]=auxF.freqExpansion(zSX,2*i) lTempYN[:,i,0]=auxF.freqExpansion(zSY,2*i) UnE=np.zeros(len(wS),dtype=np.complex_) UnE=np.squeeze(np.matmul(lTempXN,np.matmul(UnXiF,lTempYN))) return UnE
def susBubbles(self, wQ, NW): """Calculates the exchange propagators for the susceptibility of the system""" wFX = self.wFX wFG = self.wFG beTa = self.beTa gProp = self.gF gPropX = gProp(wFX, 0.0) gPropPHL = np.zeros((len(wQ), len(wFX)), dtype=np.complex_) gPropPHR = np.zeros((len(wQ), len(wFX)), dtype=np.complex_) for i in range(len(wQ)): gPropPHL[i, :] = wFG * gPropX * gProp(-wQ[i] + wFX, 0.0) gPropPHR[i, :] = wFG * gPropX * gProp(-wQ[i] + wFX, 0.0) gPHl = (1 / beTa) * np.sum(gPropPHL, axis=1) gPHr = (1 / beTa) * np.sum(gPropPHR, axis=1) (wS, wX) = np.meshgrid(wQ, wFX, indexing='ij') sPHL = np.zeros((len(wQ), 1, NW), dtype=np.complex_) sPHR = np.zeros((len(wQ), NW, 1), dtype=np.complex_) for i in range(NW): lTempWPHL = auxF.freqExpansion( auxF.forMap(0.5 * (2 * wX - wS), 1.0), 2 * i) lTempWPHR = auxF.freqExpansion( auxF.forMap(0.5 * (2 * wX - wS), 1.0), 2 * i) sPHL[:, 0, i] = (1 / beTa) * np.sum(lTempWPHL * gPropPHL, axis=1) sPHR[:, i, 0] = (1 / beTa) * np.sum(lTempWPHR * gPropPHR, axis=1) return sPHL, sPHR, gPHl, gPHr
def gBubbles(self, wQ, AC, NW): """Calculates the exchange propagtor at scale AC over NW basis functions""" wFX = self.wFX wFG = self.wFG beTa = self.beTa gProp = self.gF gPropX = gProp(wFX, AC) gPropPP = np.zeros((len(wQ), len(wFX)), dtype=np.complex_) gPropPH1 = np.zeros(gPropPP.shape, dtype=np.complex_) gPropPH2 = np.zeros(gPropPP.shape, dtype=np.complex_) for i in range(len(wQ)): gPropPP[i, :] = wFG * gPropX * gProp(wQ[i] - wFX, AC) gPropPH1[i, :] = wFG * gPropX * gProp(wQ[i] + wFX, AC) gPropPH2[i, :] = wFG * gPropX * gProp(-wQ[i] + wFX, AC) (wS, wX) = np.meshgrid(wQ, wFX, indexing='ij') wPP1 = 0.5 * (wS - 2 * wX) / np.sqrt(AC**2 + 1) wPP2 = 0.5 * (-wS + 2 * wX) / np.sqrt(AC**2 + 1) wPH1 = 0.5 * (wS + 2 * wX) / np.sqrt(AC**2 + 1) wPH2 = 0.5 * (-wS + 2 * wX) / np.sqrt(AC**2 + 1) lTempPP1 = np.zeros((len(wQ), len(wFX), NW)) lTempPP2 = np.zeros((len(wQ), len(wFX), NW)) lTempPH1 = np.zeros((len(wQ), len(wFX), NW)) lTempPH2 = np.zeros((len(wQ), len(wFX), NW)) for i in range(NW): lTempPP1[..., i] = auxF.freqExpansion(auxF.forMap(wPP1, 1.0), 2 * i) lTempPP2[..., i] = auxF.freqExpansion(auxF.forMap(wPP2, 1.0), 2 * i) lTempPH1[..., i] = auxF.freqExpansion(auxF.forMap(wPH1, 1.0), 2 * i) lTempPH2[..., i] = auxF.freqExpansion(auxF.forMap(wPH2, 1.0), 2 * i) gPP = np.zeros((len(wQ), NW, NW), dtype=np.complex_) gPH = np.zeros((len(wQ), NW, NW), dtype=np.complex_) for i in range(NW): for j in range(NW): intGPP=(lTempPP1[...,i]*lTempPP2[...,j]+\ lTempPP2[...,i]*lTempPP1[...,j])*gPropPP intGPH=lTempPH1[...,i]*lTempPH1[...,j]*gPropPH1+\ lTempPH2[...,i]*lTempPH2[...,j]*gPropPH2 gPP[:, i, j] = (0.5 / beTa) * np.sum(intGPP, axis=1) gPH[:, i, j] = (0.5 / beTa) * np.sum(intGPH, axis=1) return gPP, gPH
def __init__(self,wB,NW,beTa,UnF): """ Parameters ---------- wB : array_like(float, ndim=1) An array of bosonic frequencies at which the value of the vertex is known NW : int Current number of basis functions beTa : float Inverse temperature of the system UnF : function(wPP,wPH,wPHE) Initial two particle vertex """ self.wB=wB self.beTa=beTa self.NLmax=20 self.NW=NW UnPP = np.zeros((len(self.wB),NW,NW),dtype=np.complex_) UnPH = np.zeros((len(self.wB),NW,NW),dtype=np.complex_) UnPHE = np.zeros((len(self.wB),NW,NW),dtype=np.complex_) self.UnPP = UnPP self.UnPH = UnPH self.UnPHE = UnPHE self.uF=UnF wMidI=np.append(-wB[:0:-1],wB) self.wMidI=wMidI zFX,b=auxF.gaussianInt([-1,1],20) zFX=np.unique(np.append(auxF.forMap(wMidI,1.0),zFX)) self.zFX,self.zFG=auxF.gaussianInt(zFX,8) self.UnPPO,self.UnPHO,self.UnPHEO=self.initializeVertex() self.projectionW()
def projectionW(self): """Calculates the arrays for projection between the channels at the start of the flow""" NW=self.NW NLmax=self.NLmax wB=self.wB zFX,zFG=auxF.gaussianInt([-1,1],30) cScale=1.0 scaleDerv=np.zeros((NW,NW,NW,NW)) for i in range(NW): for j in range(NW): scaleTemp1=np.zeros((NW,NW)) scaleTemp2=np.zeros((NW,NW)) for k in range(1,NW): intG=(zFX**2)*auxF.freqExpansion(zFX,2*k)-zFX*auxF.freqExpansion(zFX,2*k-1) scaleTemp1[k,j]=2*k*np.sum(zFG*intG*auxF.freqExpansion(zFX,2*i)) intG=(zFX**2)*auxF.freqExpansion(zFX,2*k)-zFX*auxF.freqExpansion(zFX,2*k-1) scaleTemp2[i,k]=2*k*np.sum(zFG*intG*auxF.freqExpansion(zFX,2*j)) scaleDerv[:,:,i,j]=-(scaleTemp1+scaleTemp2) self.scaleDerv=scaleDerv wTransPHtoPP=np.zeros((NLmax,NW,NW,len(wB),NW,NW)) wTransPHEtoPP=np.zeros((NLmax,NW,NW,len(wB),NW,NW)) wTransPPtoPH=np.zeros((NLmax,NW,NW,len(wB),NW,NW)) wTransPHEtoPH=np.zeros((NLmax,NW,NW,len(wB),NW,NW)) wTransPPtoPHE=np.zeros((NLmax,NW,NW,len(wB),NW,NW)) wTransPHtoPHE=np.zeros((NLmax,NW,NW,len(wB),NW,NW)) wFX=auxF.backMap(zFX,cScale) wP1=np.tile(wFX[:,np.newaxis,np.newaxis],(1,len(wFX),len(wB))) wP2=np.tile(wFX[np.newaxis,:,np.newaxis],(len(zFX),1,len(wB))) wBE=np.tile(wB[np.newaxis,np.newaxis,:],(len(zFX),len(zFX),1)) wFXE=np.tile(wFX[:,np.newaxis],(1,len(wB))) wBEe=np.tile(wB[np.newaxis,:],(len(zFX),1)) zP1=np.tile(zFX[:,np.newaxis,np.newaxis],(1,len(zFX),len(wB))) zP2=np.tile(zFX[np.newaxis,:,np.newaxis],(len(zFX),1,len(wB))) zPE=np.tile(zFG[:,np.newaxis,np.newaxis],(1,len(zFX),len(wB))) zPE=zPE*np.tile(zFG[np.newaxis,:,np.newaxis],(len(zFX),1,len(wB))) lTempXtoY1=np.zeros((len(zFX),len(zFX),len(wB),NLmax)) lTempXtoY2=np.zeros((len(zFX),len(zFX),len(wB),NLmax)) for i in range(NLmax): zT=auxF.forMap((wP1+wP2),cScale) lTempXtoY1[...,i]=zPE*auxF.freqExpansion(zT,2*i) zT=auxF.forMap((wP2-wP1),cScale) lTempXtoY2[...,i]=zPE*auxF.freqExpansion(zT,2*i) lTempP1=np.zeros((len(zFX),len(zFX),len(wB),NW)) lTempP2=np.zeros((len(zFX),len(zFX),len(wB),NW)) lTempP3=np.zeros((len(zFX),len(zFX),len(wB),NW)) lTempP4=np.zeros((len(zFX),len(zFX),len(wB),NW)) lTempW1=np.zeros((len(zFX),len(zFX),len(wB),NW)) lTempWn=np.zeros((len(zFX),len(wB),NW)) for i in range(NW): zT=auxF.forMap(0.5*(wBE-(wP2-wP1)),cScale) lTempP1[...,i]=auxF.freqExpansion(zT,2*i) zT=auxF.forMap(0.5*(wBE+(wP2-wP1)),cScale) lTempP2[...,i]=auxF.freqExpansion(zT,2*i) zT=auxF.forMap(0.5*(wBE-(wP1+wP2)),cScale) lTempP3[...,i]=auxF.freqExpansion(zT,2*i) zT=auxF.forMap(0.5*(wBE+(wP1+wP2)),cScale) lTempP4[...,i]=auxF.freqExpansion(zT,2*i) lTempW1[...,i]=auxF.freqExpansion(zP1,2*i) lTempWn[...,i]=auxF.freqExpansion(auxF.forMap(wFXE,cScale),2*i) wTemp1=np.zeros((len(zFX),NW,NW,len(wB),NW)) wTemp2=np.zeros((len(zFX),NW,NW,len(wB),NW)) for i in range(NLmax): for j in range(NW): for k in range(NW): for l in range(NW): wTemp1[:,j,k,:,l]=np.sum(lTempXtoY1[...,i]*lTempP1[...,j]*lTempP2[...,k]*lTempW1[...,l],axis=0) wTemp2[:,j,k,:,l]=np.sum(lTempXtoY2[...,i]*lTempP3[...,j]*lTempP4[...,k]*lTempW1[...,l],axis=0) for j in range(NW): intG=lTempWn[...,j] intG=np.tile(intG[:,np.newaxis,np.newaxis,:,np.newaxis],(1,NW,NW,1,NW)) wTransPHtoPP[i,:,:,:,:,j]=np.sum(intG*wTemp1,axis=0) wTransPHEtoPP[i,:,:,:,:,j]=np.sum(intG*wTemp2,axis=0) wTransPPtoPH=wTransPHtoPP[:] for j in range(NW): wTransPHEtoPH[:,j,:,:,:,:]=wTransPHEtoPP[:,j,:,:,:,:] wTransPPtoPHE[:,j,:,:,:,:]=wTransPHtoPP[:,j,:,:,:,:] wTransPHtoPHE[:,j,:,:,:,:]=wTransPHEtoPP[:,j,:,:,:,:] self.wTransPHtoPP=wTransPHtoPP self.wTransPHEtoPP=wTransPHEtoPP self.wTransPPtoPH=wTransPPtoPH self.wTransPHEtoPH=wTransPHEtoPH self.wTransPPtoPHE=wTransPPtoPHE self.wTransPHtoPHE=wTransPHtoPHE
def xBubbles(self, wQ, dSEwMid, AC, NW): """Calculates the single scale exchange propagator over the NW basis functions""" beTa = self.beTa wFX = self.wFX wFG = self.wFG wFI = self.wFI dSE = np.zeros(len(wFX), dtype=np.complex_) dSEI = np.append(np.conj(dSEwMid[::-1]), dSEwMid) dSE += np.interp(wFX, wFI, dSEI.real) dSE += 1j * np.interp(wFX, wFI, dSEI.imag) gProp = self.gF sProp = self.sF(wFX, AC) + dSE * (gProp(wFX, AC)**2) sPropPP = np.zeros((len(wQ), len(wFX)), dtype=np.complex_) sPropPH1 = np.zeros(sPropPP.shape, dtype=np.complex_) sPropPH2 = np.zeros(sPropPP.shape, dtype=np.complex_) for i in range(len(wQ)): sPropPP[i, :] = wFG * sProp * gProp(wQ[i] - wFX, AC) sPropPH1[i, :] = wFG * sProp * gProp(wQ[i] + wFX, AC) sPropPH2[i, :] = wFG * sProp * gProp(-wQ[i] + wFX, AC) (wS, wX) = np.meshgrid(wQ, wFX, indexing='ij') wPP1 = 0.5 * (wS - 2 * wX) / np.sqrt(AC**2 + 1) wPP2 = 0.5 * (-wS + 2 * wX) / np.sqrt(AC**2 + 1) wPH1 = 0.5 * (wS + 2 * wX) / np.sqrt(AC**2 + 1) wPH2 = 0.5 * (-wS + 2 * wX) / np.sqrt(AC**2 + 1) lTempPP1 = np.zeros((len(wQ), len(wFX), NW)) lTempPP2 = np.zeros((len(wQ), len(wFX), NW)) lTempPH1 = np.zeros((len(wQ), len(wFX), NW)) lTempPH2 = np.zeros((len(wQ), len(wFX), NW)) for i in range(NW): lTempPP1[..., i] = auxF.freqExpansion(auxF.forMap(wPP1, 1.0), 2 * i) lTempPP2[..., i] = auxF.freqExpansion(auxF.forMap(wPP2, 1.0), 2 * i) lTempPH1[..., i] = auxF.freqExpansion(auxF.forMap(wPH1, 1.0), 2 * i) lTempPH2[..., i] = auxF.freqExpansion(auxF.forMap(wPH2, 1.0), 2 * i) mixPP = np.zeros((len(wQ), NW, NW), dtype=np.complex_) mixPH = np.zeros((len(wQ), NW, NW), dtype=np.complex_) for i in range(NW): for j in range(NW): intGPP=(lTempPP1[...,i]*lTempPP2[...,j]+\ lTempPP2[...,i]*lTempPP1[...,j])*sPropPP intGPH=lTempPH1[...,i]*lTempPH1[...,j]*sPropPH1+\ lTempPH2[...,i]*lTempPH2[...,j]*sPropPH2 mixPP[:, i, j] = (1 / beTa) * np.sum(intGPP, axis=1) mixPH[:, i, j] = (1 / beTa) * np.sum(intGPH, axis=1) return mixPP, mixPH