def simulate(self, vI, vQ, dTimeStep, dDelta, dDetuning, dRabiAmp, \ dDriveFreq, nReshape, nRep, lNoise, bRWA=False, bRotFrame=True, hDriveFunc=None, noise_epsilon=None, noise_delta=None): # simulate the time evolution for the start state vStart # a state is defined as [Psi0 Psi1]' # a vector of states is a matrix, defined as [state1 state2 ... stateN] # # define start state vStart = np.r_[1.0, 0.0] dDelta0 = dDelta # introduce a drive to the detuning vTime = np.arange(len(vI)) * dTimeStep dTimeZero = 0 # create drive waveform, check if rotating wave approximation if bRWA: vDrive = -1j * dRabiAmp * vI * 0.5 + dRabiAmp * vQ * 0.5 else: # project the start state to a right/left circulating current basis vStart = self.convertToLeftRight(vStart, dDelta0, dDetuning) if hDriveFunc is None: vDrive = -\ dRabiAmp*vI*np.sin(2*np.pi*dDriveFreq*(vTime)) + \ dRabiAmp*vQ*np.cos(2*np.pi*dDriveFreq*(vTime)) else: vDrive = hDriveFunc(vTime, vI, vQ) # # pre-allocate result vector vTimeReshape = vTime[0::nReshape] vP1 = np.zeros(len(vTimeReshape)) vPx = np.zeros(len(vTimeReshape)) vPy = np.zeros(len(vTimeReshape)) # self.mPx = np.zeros((nRep, len(vTimeReshape))) self.mPy = np.zeros((nRep, len(vTimeReshape))) self.mPz = np.zeros((nRep, len(vTimeReshape))) # mSx = np.array([[0., 1.], [1., 0.]]) mSy = np.array([[0., -1j], [1j, 0.]]) # create static noise vector vStaticDelta = np.zeros(nRep) vStaticDet = np.zeros(nRep) vStaticDrive = np.zeros(nRep) if nRep > 1: # high-frequency cut-off for static noise is length of waveform dStaticHF = 1 / (1e-9 * vTime[-1]) for noise in lNoise: noise.addStaticNoise(vStaticDelta, vStaticDet, vStaticDrive, dStaticHF, 1E-9) # figure out resampling of input noise if (noise_epsilon is not None): n = len(noise_epsilon['y']) // nRep noise_epsilon_t = np.arange(n) * noise_epsilon['dt'] * 1E9 # create matrix with noise data noise_eps_m = 1E-9 * noise_epsilon['y'][:(nRep * n)].reshape( (nRep, n)) if (noise_delta is not None): n = len(noise_delta['y']) // nRep noise_delta_t = np.arange(n) * noise_delta['dt'] * 1E9 # create matrix with noise data noise_delta_m = 1E-9 * noise_delta['y'][:(nRep * n)].reshape( (nRep, n)) # find indices with pulses to be able to remove noise during pulses if self.bRemoveNoise: pulse_indx = np.where((np.abs(vI) + np.abs(vQ)) > 1E-15)[0] # calculate color codes based on total noise vColNoise = (vStaticDelta + vStaticDet) dNoiseColAmp = np.max(np.abs(vColNoise)) if dNoiseColAmp > 0: vColNoise /= dNoiseColAmp # rotatation matrice mRotX = splin.expm(-1j * 0.5 * np.pi * 0.5 * mSx) mRotY = splin.expm(-1j * 0.5 * np.pi * 0.5 * mSy) for n1 in range(nRep): # create new vectors for delta and detuning for each time step vDelta = np.zeros(len(vTime)) + vStaticDelta[n1] vDetuning = np.zeros(len(vTime)) + vStaticDet[n1] # add noise to both delta and epsilon from all noise sources if nRep > 1: for noise in lNoise: noise.addNoise(vDelta, vDetuning, dTimeStep * 1E-9, 1E-9) # add externally applied noise for the right repetition if (noise_epsilon is not None): noise_data = np.interp(vTime, noise_epsilon_t, noise_eps_m[n1]) vDetuning += noise_data if (noise_delta is not None): noise_data = np.interp(vTime, noise_delta_t, noise_delta_m[n1]) vDelta += noise_data # if wanted, remove noise where pulses are applied if self.bRemoveNoise: vDelta[pulse_indx] = 0.0 vDetuning[pulse_indx] = 0.0 # combine noise with static bias points vDelta += dDelta vDetuning += dDetuning # do simulation, either using RWA or full Hamiltonian if bRWA: # new frame, refer to drive frequency vDetuning = np.sqrt(vDetuning**2 + vDelta**2) - dDriveFreq mState = integrateHy(vStart, vTime, np.real(vDrive), vDetuning, -np.imag(vDrive), nReshape) # mState = self.integrateH(vStart, vTime, np.real(vDrive), vDetuning, # np.imag(vDrive), nReshape) else: # two different methonds depending if using Y-drive or not if self.bDriveCharge: # drive on Y (= charge) vY = vDrive * (1.0 + vStaticDrive[n1]) mState = integrateHy(vStart, vTime, vDelta, vDetuning, vY, nReshape) # mState = self.integrateH(vStart, vTime, vDelta, vDetuning, vY, nReshape) else: # drive on Z (= flux) vDetuning += vDrive * (1.0 + vStaticDrive[n1]) mState = integrateH(vStart, vTime, vDelta, vDetuning, nReshape) # vY = np.zeros_like(vDrive) # mState = self.integrateH(vStart, vTime, vDelta, vDetuning, vY, nReshape) # convert the results to an eigenbasis of dDelta, dDetuning mState = self.convertToEigen(mState, dDelta0, dDetuning) # go to the rotating frame (add timeStep/2 to get the right phase) if bRotFrame: mState = self.goToRotatingFrame(mState, vTimeReshape, dDriveFreq, dTimeZero + dTimeStep / 2) # get probablity of measuring p1 mStateEig = mState self.mPz[n1, :] = np.real(mStateEig[1, :] * np.conj(mStateEig[1, :])) vP1 += self.mPz[n1, :] # get projection on X and Y mStateEig = np.dot(mRotX, mState) self.mPx[n1, :] = np.real(mStateEig[1, :] * np.conj(mStateEig[1, :])) vPx += self.mPx[n1, :] mStateEig = np.dot(mRotY, mState) self.mPy[n1, :] = np.real(mStateEig[1, :] * np.conj(mStateEig[1, :])) vPy += self.mPy[n1, :] # divide to get average vP1 = vP1 / nRep vPx = vPx / nRep vPy = vPy / nRep # convert to projections vP1 = -(2 * vP1 - 1) vPx = 2 * vPx - 1 vPy = 2 * vPy - 1 self.mPz = -(2 * self.mPz - 1) self.mPx = 2 * self.mPx - 1 self.mPy = 2 * self.mPy - 1 return (vP1, vPx, vPy, vTimeReshape, vColNoise)
def simulate(self, vI, vQ, dTimeStep, dDelta, dDetuning, dRabiAmp, \ dDriveFreq, nReshape, nRep, lNoise, bRWA=False, bRotFrame=True, hDriveFunc=None): # simulate the time evolution for the start state vStart # a state is defined as [Psi0 Psi1]' # a vector of states is a matrix, defined as [state1 state2 ... stateN] # # define start state vStart = np.r_[1, 0] dDelta0 = dDelta # project the start state to a right/left circulating current basis vStart = self.convertToLeftRight(vStart, dDelta0, dDetuning) # introduce a drive to the detuning vTime = np.arange(len(vI)) * dTimeStep dTimeZero = 0 # check if rotating wave approximation if bRWA: dDelta = dDelta - dDriveFreq dDriveFreq = 0 vDetuning = dDetuning - 1j * dRabiAmp * vI * 0.5 + dRabiAmp * vQ * 0.5 else: if hDriveFunc is None: vDetuning = dDetuning - \ dRabiAmp*vI*np.sin(2*np.pi*dDriveFreq*(vTime)) + \ dRabiAmp*vQ*np.cos(2*np.pi*dDriveFreq*(vTime)) else: vDetuning = dDetuning + hDriveFunc(vTime, vI, vQ) # # pre-allocate result vector vTimeReshape = vTime[0::nReshape] vP1 = np.zeros(len(vTimeReshape)) vPx = np.zeros(len(vTimeReshape)) vPy = np.zeros(len(vTimeReshape)) # self.mPx = np.zeros((nRep, len(vTimeReshape))) self.mPy = np.zeros((nRep, len(vTimeReshape))) self.mPz = np.zeros((nRep, len(vTimeReshape))) # mSx = np.array([[0., 1.], [1., 0.]]) mSy = np.array([[0., -1j], [1j, 0.]]) # create static noise vector vStaticDelta = np.zeros(nRep) vStaticDet = np.zeros(nRep) vStaticDrive = np.zeros(nRep) if nRep > 1: # high-frequency cut-off for static noise is length of waveform dStaticHF = 1 / (1e-9 * vTime[-1]) for noise in lNoise: noise.addStaticNoise(vStaticDelta, vStaticDet, vStaticDrive, dStaticHF, 1E-9) # calculate color codes based on total noise vColNoise = (vStaticDelta + vStaticDet) dNoiseColAmp = np.max(np.abs(vColNoise)) if dNoiseColAmp > 0: vColNoise /= dNoiseColAmp # rotatation matrice mRotX = splin.expm(-1j * 0.5 * np.pi * 0.5 * mSx) mRotY = splin.expm(-1j * 0.5 * np.pi * 0.5 * mSy) for n1 in range(nRep): # create new vectors for delta and detuning for each time step vDelta = dDelta * np.ones(len(vTime)) + vStaticDelta[n1] vDetNoise = vDetuning.copy() * (1.0 + vStaticDrive[n1]) + vStaticDet[n1] # add noise to both delta and epsilon from all noise sources if nRep > 1: for noise in lNoise: noise.addNoise(vDelta, vDetNoise, dTimeStep * 1E-9, 1E-9) # do simulation if bRWA: mState = integrateH_RWA(vStart, vTime, vDelta, np.real(vDetNoise), np.imag(vDetNoise), nReshape) # mState = self.integrateH_RWA(vStart, vTime, vDelta, np.real(vDetNoise), # np.imag(vDetNoise), nReshape) else: mState = integrateH(vStart, vTime, vDelta, vDetNoise, nReshape) # mState = self.integrateH(vStart, vTime, vDelta, vDetNoise, nReshape) # convert the results to an eigenbasis of dDelta, dDetuning mState = self.convertToEigen(mState, dDelta0, dDetuning) # go to the rotating frame (add timeStep/2 to get the right phase) if bRotFrame and not bRWA: mState = self.goToRotatingFrame(mState, vTimeReshape, dDriveFreq, dTimeZero + dTimeStep / 2) # get probablity of measuring p1 mStateEig = mState self.mPz[n1, :] = np.real(mStateEig[1, :] * np.conj(mStateEig[1, :])) vP1 += self.mPz[n1, :] # get projection on X and Y mStateEig = np.dot(mRotX, mState) self.mPx[n1, :] = np.real(mStateEig[1, :] * np.conj(mStateEig[1, :])) vPx += self.mPx[n1, :] mStateEig = np.dot(mRotY, mState) self.mPy[n1, :] = np.real(mStateEig[1, :] * np.conj(mStateEig[1, :])) vPy += self.mPy[n1, :] # divide to get average vP1 = vP1 / nRep vPx = vPx / nRep vPy = vPy / nRep # convert to projections vP1 = -(2 * vP1 - 1) vPx = 2 * vPx - 1 vPy = 2 * vPy - 1 self.mPz = -(2 * self.mPz - 1) self.mPx = 2 * self.mPx - 1 self.mPy = 2 * self.mPy - 1 return (vP1, vPx, vPy, vTimeReshape, vColNoise)
def simulate(self, vI, vQ, dTimeStep, dDelta, dDetuning, dRabiAmp, \ dDriveFreq, nReshape, nRep, lNoise, bRWA=False, bRotFrame=True, hDriveFunc=None): # simulate the time evolution for the start state vStart # a state is defined as [Psi0 Psi1]' # a vector of states is a matrix, defined as [state1 state2 ... stateN] # # define start state vStart = np.r_[1,0] dDelta0 = dDelta # project the start state to a right/left circulating current basis vStart = self.convertToLeftRight(vStart, dDelta0, dDetuning) # introduce a drive to the detuning vTime = np.arange(len(vI))*dTimeStep dTimeZero = 0 # check if rotating wave approximation if bRWA: dDelta = dDelta - dDriveFreq dDriveFreq = 0 vDetuning = dDetuning - 1j*dRabiAmp*vI*0.5 + dRabiAmp*vQ*0.5 else: if hDriveFunc is None: vDetuning = dDetuning - \ dRabiAmp*vI*np.sin(2*np.pi*dDriveFreq*(vTime)) + \ dRabiAmp*vQ*np.cos(2*np.pi*dDriveFreq*(vTime)) else: vDetuning = dDetuning + hDriveFunc(vTime, vI, vQ) # # pre-allocate result vector vTimeReshape = vTime[0::nReshape] vP1 = np.zeros(len(vTimeReshape)) vPx = np.zeros(len(vTimeReshape)) vPy = np.zeros(len(vTimeReshape)) # self.mPx = np.zeros((nRep, len(vTimeReshape))) self.mPy = np.zeros((nRep, len(vTimeReshape))) self.mPz = np.zeros((nRep, len(vTimeReshape))) # mSx = np.array([[0., 1.],[1., 0.]]) mSy = np.array([[0., -1j],[1j, 0.]]) # create static noise vector vStaticDelta = np.zeros(nRep) vStaticDet = np.zeros(nRep) vStaticDrive = np.zeros(nRep) if nRep>1: # high-frequency cut-off for static noise is length of waveform dStaticHF = 1/(1e-9*vTime[-1]) for noise in lNoise: noise.addStaticNoise(vStaticDelta, vStaticDet, vStaticDrive, dStaticHF, 1E-9) # calculate color codes based on total noise vColNoise = (vStaticDelta + vStaticDet) dNoiseColAmp = np.max(np.abs(vColNoise)) if dNoiseColAmp>0: vColNoise /= dNoiseColAmp # rotatation matrice mRotX = splin.expm(-1j*0.5*np.pi*0.5*mSx) mRotY = splin.expm(-1j*0.5*np.pi*0.5*mSy) for n1 in range(nRep): # create new vectors for delta and detuning for each time step vDelta = dDelta * np.ones(len(vTime)) + vStaticDelta[n1] vDetNoise = vDetuning.copy()*(1.0+vStaticDrive[n1]) + vStaticDet[n1] # add noise to both delta and epsilon from all noise sources if nRep>1: for noise in lNoise: noise.addNoise(vDelta, vDetNoise, dTimeStep*1E-9, 1E-9) # do simulation if bRWA: mState = integrateH_RWA(vStart, vTime, vDelta, np.real(vDetNoise), np.imag(vDetNoise), nReshape) # mState = self.integrateH_RWA(vStart, vTime, vDelta, np.real(vDetNoise), # np.imag(vDetNoise), nReshape) else: mState = integrateH(vStart, vTime, vDelta, vDetNoise, nReshape) # mState = self.integrateH(vStart, vTime, vDelta, vDetNoise, nReshape) # convert the results to an eigenbasis of dDelta, dDetuning mState = self.convertToEigen(mState, dDelta0, dDetuning) # go to the rotating frame (add timeStep/2 to get the right phase) if bRotFrame and not bRWA: mState = self.goToRotatingFrame(mState, vTimeReshape, dDriveFreq, dTimeZero+dTimeStep/2) # get probablity of measuring p1 mStateEig = mState self.mPz[n1,:] = np.real(mStateEig[1,:]*np.conj(mStateEig[1,:])) vP1 += self.mPz[n1,:] # get projection on X and Y mStateEig = np.dot(mRotX,mState) self.mPx[n1,:] = np.real(mStateEig[1,:]*np.conj(mStateEig[1,:])) vPx += self.mPx[n1,:] mStateEig = np.dot(mRotY,mState) self.mPy[n1,:] = np.real(mStateEig[1,:]*np.conj(mStateEig[1,:])) vPy += self.mPy[n1,:] # divide to get average vP1 = vP1/nRep vPx = vPx/nRep vPy = vPy/nRep # convert to projections vP1 = -(2*vP1 - 1) vPx = 2*vPx - 1 vPy = 2*vPy - 1 self.mPz = -(2*self.mPz - 1) self.mPx = 2*self.mPx - 1 self.mPy = 2*self.mPy - 1 return (vP1, vPx, vPy, vTimeReshape, vColNoise)