def plot_wavefunction(self,
esys=None,
which=0,
phi_grid=None,
theta_grid=None,
mode="abs",
zero_calibrate=True,
**kwargs) -> Tuple[Figure, Axes]:
"""
Plots a 2D wave function in :math:`\\theta, \\phi` basis, at :math:`\\zeta = 0`
Parameters
----------
esys: ndarray, ndarray
eigenvalues, eigenvectors as obtained from `.eigensystem()`
which: int, optional
index of wave function to be plotted (default value = (0)
phi_grid: Grid1d, option
used for setting a custom grid for phi; if None use self._default_phi_grid
theta_grid: Grid1d, option
used for setting a custom grid for theta; if None use
self._default_theta_grid
mode: str, optional
choices as specified in `constants.MODE_FUNC_DICT` (default value = 'abs_sqr')
zero_calibrate: bool, optional
if True, colors are adjusted to use zero wavefunction amplitude as the neutral color in the palette
**kwargs:
plot options
"""
phi_grid = phi_grid or self._default_phi_grid
zeta_grid = discretization.Grid1d(0, 0, 1)
theta_grid = theta_grid or self._default_theta_grid
amplitude_modifier = constants.MODE_FUNC_DICT[mode]
wavefunc = self.wavefunction(
esys,
phi_grid=phi_grid,
zeta_grid=zeta_grid,
theta_grid=theta_grid,
which=which,
)
wavefunc.gridspec = discretization.GridSpec(
np.asarray([
[phi_grid.min_val, phi_grid.max_val, phi_grid.pt_count],
[theta_grid.min_val, theta_grid.max_val, theta_grid.pt_count],
]))
wavefunc.amplitudes = np.transpose(
amplitude_modifier(
spec_utils.standardize_phases(
wavefunc.amplitudes.reshape(phi_grid.pt_count,
theta_grid.pt_count))))
return plot.wavefunction2d(wavefunc,
zero_calibrate=zero_calibrate,
ylabel=r"$\theta$",
xlabel=r"$\phi$",
**kwargs)
def wavefunction(self,
esys=None,
which=0,
theta_range=None,
theta_count=None):
"""Returns a zero-pi wave function in `phi`, `theta` basis
Parameters
----------
esys: ndarray, ndarray
eigenvalues, eigenvectors
which: int, optional
index of desired wave function (default value = 0)
theta_range: tuple(float, float), optional
used for setting a custom plot range for theta
theta_count: int, optional
number of points to be used in the interval for theta
Returns
-------
WaveFunctionOnGrid object
"""
evals_count = max(which + 1, 3)
if esys is None:
_, evecs = self.eigensys(evals_count)
else:
_, evecs = esys
theta_range, theta_count = self.try_defaults(theta_range, theta_count)
pt_count = self.grid.pt_count
dim_theta = 2 * self.ncut + 1
state_amplitudes = evecs[:, which].reshape(pt_count, dim_theta)
# Calculate psi_{phi, theta} = sum_n state_amplitudes_{phi, n} A_{n, theta}
# where a_{n, theta} = 1/sqrt(2 pi) e^{i n theta}
n_vec = np.arange(-self.ncut, self.ncut + 1)
theta_vec = np.linspace(*theta_range, theta_count)
a_n_theta = np.exp(1j * np.outer(n_vec, theta_vec)) / (2 * np.pi)**0.5
wavefunc_amplitudes = np.matmul(state_amplitudes, a_n_theta).T
wavefunc_amplitudes = standardize_phases(wavefunc_amplitudes)
grid2d = GridSpec(
np.asarray([[self.grid.min_val, self.grid.max_val, pt_count],
[*theta_range, theta_count]]))
return WaveFunctionOnGrid(grid2d, wavefunc_amplitudes)
def wavefunction(
self,
esys: Tuple[ndarray, ndarray] = None,
which: int = 0,
phi_grid: discretization.Grid1d = None,
) -> storage.WaveFunctionOnGrid:
"""
Return a flux qubit wave function in phi1, phi2 basis
Parameters
----------
esys:
eigenvalues, eigenvectors
which:
index of desired wave function (default value = 0)
phi_grid:
used for setting a custom grid for phi; if None use self._default_grid
"""
evals_count = max(which + 1, 3)
if esys is None:
_, evecs = self.eigensys(evals_count)
else:
_, evecs = esys
phi_grid = phi_grid or self._default_grid
dim = 2 * self.ncut + 1
state_amplitudes = np.reshape(evecs[:, which], (dim, dim))
n_vec = np.arange(-self.ncut, self.ncut + 1)
phi_vec = phi_grid.make_linspace()
a_1_phi = np.exp(1j * np.outer(phi_vec, n_vec)) / (2 * np.pi) ** 0.5
a_2_phi = a_1_phi.T
wavefunc_amplitudes = np.matmul(a_1_phi, state_amplitudes)
wavefunc_amplitudes = np.matmul(wavefunc_amplitudes, a_2_phi)
wavefunc_amplitudes = spec_utils.standardize_phases(wavefunc_amplitudes)
grid2d = discretization.GridSpec(
np.asarray(
[
[phi_grid.min_val, phi_grid.max_val, phi_grid.pt_count],
[phi_grid.min_val, phi_grid.max_val, phi_grid.pt_count],
]
)
)
return storage.WaveFunctionOnGrid(grid2d, wavefunc_amplitudes)
def wavefunction(
self,
esys: Tuple[ndarray, ndarray] = None,
which: int = 0,
theta_grid: Grid1d = None,
) -> WaveFunctionOnGrid:
"""Returns a zero-pi wave function in `phi`, `theta` basis
Parameters
----------
esys:
eigenvalues, eigenvectors
which:
index of desired wave function (default value = 0)
theta_grid:
used for setting a custom grid for theta; if None use self._default_grid
"""
evals_count = max(which + 1, 3)
if esys is None:
_, evecs = self.eigensys(evals_count)
else:
_, evecs = esys
theta_grid = theta_grid or self._default_grid
dim_theta = 2 * self.ncut + 1
state_amplitudes = evecs[:, which].reshape(self.grid.pt_count, dim_theta)
# Calculate psi_{phi, theta} = sum_n state_amplitudes_{phi, n} A_{n, theta}
# where a_{n, theta} = 1/sqrt(2 pi) e^{i n theta}
n_vec = np.arange(-self.ncut, self.ncut + 1)
theta_vec = theta_grid.make_linspace()
a_n_theta = np.exp(1j * np.outer(n_vec, theta_vec)) / (2 * np.pi) ** 0.5
wavefunc_amplitudes = np.matmul(state_amplitudes, a_n_theta).T
wavefunc_amplitudes = spec_utils.standardize_phases(wavefunc_amplitudes)
grid2d = discretization.GridSpec(
np.asarray(
[
[self.grid.min_val, self.grid.max_val, self.grid.pt_count],
[theta_grid.min_val, theta_grid.max_val, theta_grid.pt_count],
]
)
)
return storage.WaveFunctionOnGrid(grid2d, wavefunc_amplitudes)
def wavefunction(self, esys=None, which=0, phi_range=None, phi_count=None):
"""
Return a flux qubit wave function in phi1, phi2 basis
Parameters
----------
esys: ndarray, ndarray
eigenvalues, eigenvectors
which: int, optional
index of desired wave function (default value = 0)
phi_range: tuple(float, float), optional
used for setting a custom plot range for phi
phi_count: int, optional
number of points to use on grid in each direction
Returns
-------
WaveFunctionOnGrid object
"""
evals_count = max(which + 1, 3)
if esys is None:
_, evecs = self.eigensys(evals_count)
else:
_, evecs = esys
phi_range, phi_count = self.try_defaults(phi_range, phi_count)
dim = 2 * self.ncut + 1
state_amplitudes = np.reshape(evecs[:, which], (dim, dim))
n_vec = np.arange(-self.ncut, self.ncut + 1)
phi_vec = np.linspace(*phi_range, phi_count)
a_1_phim = np.exp(-1j * np.outer(phi_vec, n_vec)) / (2 * np.pi)**0.5
a_2_phip = np.exp(1j * np.outer(n_vec, phi_vec)) / (2 * np.pi)**0.5
wavefunc_amplitudes = np.matmul(a_1_phim, state_amplitudes)
wavefunc_amplitudes = np.matmul(wavefunc_amplitudes, a_2_phip).T
wavefunc_amplitudes = standardize_phases(wavefunc_amplitudes)
grid2d = GridSpec(
np.asarray([[*phi_range, phi_count], [*phi_range, phi_count]]))
return WaveFunctionOnGrid(grid2d, wavefunc_amplitudes)