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)