def eigensys(
self,
evals_count: int = 6,
filename: str = None,
return_spectrumdata: bool = False,
) -> Tuple[ndarray, ndarray]:
"""Calculates eigenvalues and corresponding eigenvectors using
`scipy.linalg.eigh`. Returns two numpy arrays containing the eigenvalues and
eigenvectors, respectively.
Parameters
----------
evals_count:
number of desired eigenvalues/eigenstates (default value = 6)
filename:
path and filename without suffix, if file output desired
(default value = None)
return_spectrumdata:
if set to true, the returned data is provided as a SpectrumData object
(default value = False)
Returns
-------
eigenvalues, eigenvectors as numpy arrays or in form of a SpectrumData object
"""
evals, evecs = self._esys_calc(evals_count)
if filename or return_spectrumdata:
specdata = SpectrumData(energy_table=evals,
system_params=self.get_initdata(),
state_table=evecs)
if filename:
specdata.filewrite(filename)
return specdata if return_spectrumdata else (evals,
evecs) # type: ignore
def eigenvals(
self,
evals_count: int = 6,
filename: str = None,
return_spectrumdata: bool = False,
) -> ndarray:
"""Calculates eigenvalues using `scipy.linalg.eigh`, returns numpy array of
eigenvalues.
Parameters
----------
evals_count:
number of desired eigenvalues/eigenstates (default value = 6)
filename:
path and filename without suffix, if file output desired
(default value = None)
return_spectrumdata:
if set to true, the returned data is provided as a SpectrumData object
(default value = False)
Returns
-------
eigenvalues as ndarray or in form of a SpectrumData object
"""
evals = self._evals_calc(evals_count)
if filename or return_spectrumdata:
specdata = SpectrumData(energy_table=evals,
system_params=self.get_initdata())
if filename:
specdata.filewrite(filename)
return specdata if return_spectrumdata else evals
def eigensys(self, evals_count=6, filename=None):
"""Calculates eigenvalues and corresponding eigenvectors using `scipy.linalg.eigh`. Returns
two numpy arrays containing the eigenvalues and eigenvectors, respectively.
Parameters
----------
evals_count: int, optional
number of desired eigenvalues/eigenstates (default value = 6)
filename: str, optional
path and filename without suffix, if file output desired (default value = None)
Returns
-------
ndarray, ndarray
eigenvalues, eigenvectors
"""
evals, evecs = self._esys_calc(evals_count)
if filename:
specdata = SpectrumData('const_parameters',
param_vals=np.empty(0),
energy_table=evals,
system_params=self._get_metadata_dict(),
state_table=evecs)
specdata.filewrite(filename)
return evals, evecs
def eigenvals(self, evals_count=6, filename=None):
"""Calculates eigenvalues using `scipy.linalg.eigh`, returns numpy array of eigenvalues.
Parameters
----------
evals_count: int
number of desired eigenvalues/eigenstates (default value = 6)
filename: str, optional
path and filename without suffix, if file output desired (default value = None)
Returns
-------
ndarray
"""
evals = self._evals_calc(evals_count)
if filename:
specdata = SpectrumData(energy_table=evals,
system_params=self._get_metadata_dict())
specdata.filewrite(filename)
return evals
def matrixelement_table(self,
operator,
evecs=None,
evals_count=6,
filename=None):
"""Returns table of matrix elements for `operator` with respect to the eigenstates of the qubit.
The operator is given as a string matching a class method returning an operator matrix.
E.g., for an instance `trm` of Transmon, the matrix element table for the charge operator is given by
`trm.op_matrixelement_table('n_operator')`.
When `esys` is set to `None`, the eigensystem is calculated on-the-fly.
Parameters
----------
operator: str
name of class method in string form, returning operator matrix in qubit-internal basis.
evecs: ndarray, optional
if not provided, then the necesssary eigenstates are calculated on the fly
evals_count: int, optional
number of desired matrix elements, starting with ground state (default value = 6)
filename: str, optional
output file name
Returns
-------
ndarray
"""
if evecs is None:
_, evecs = self.eigensys(evals_count=evals_count)
operator_matrix = getattr(self, operator)()
table = get_matrixelement_table(operator_matrix, evecs)
if filename:
specdata = SpectrumData(energy_table=np.empty(0),
system_params=self._get_metadata_dict(),
param_name='const_parameters',
param_vals=np.empty(0),
matrixelem_table=table)
specdata.filewrite(filename)
return table
def get_spectrum_vs_paramvals(
self,
param_name: str,
param_vals: ndarray,
evals_count: int = 6,
subtract_ground: bool = False,
get_eigenstates: bool = False,
filename: str = None,
num_cpus: int = settings.NUM_CPUS,
) -> SpectrumData:
"""Calculates eigenvalues/eigenstates for a varying system parameter,
given an array of parameter values. Returns a `SpectrumData` object with
`energy_data[n]` containing eigenvalues calculated for parameter value
`param_vals[n]`.
Parameters
----------
param_name:
name of parameter to be varied
param_vals:
parameter values to be plugged in
evals_count:
number of desired eigenvalues (sorted from smallest to largest)
(default value = 6)
subtract_ground:
if True, eigenvalues are returned relative to the ground state eigenvalue
(default value = False)
get_eigenstates:
return eigenstates along with eigenvalues (default value = False)
filename:
file name if direct output to disk is wanted
num_cpus:
number of cores to be used for computation
(default value: settings.NUM_CPUS)
"""
previous_paramval = getattr(self, param_name)
tqdm_disable = num_cpus > 1 or settings.PROGRESSBAR_DISABLED
target_map = get_map_method(num_cpus)
if not get_eigenstates:
func = functools.partial(self._evals_for_paramval,
param_name=param_name,
evals_count=evals_count)
with InfoBar(
"Parallel computation of eigensystems [num_cpus={}]".
format(num_cpus),
num_cpus,
):
eigenvalue_table = list(
target_map(
func,
tqdm(
param_vals,
desc="Spectral data",
leave=False,
disable=tqdm_disable,
),
))
eigenvalue_table = np.asarray(eigenvalue_table)
eigenstate_table = None
else:
func = functools.partial(self._esys_for_paramval,
param_name=param_name,
evals_count=evals_count)
with InfoBar(
"Parallel computation of eigenvalues [num_cpus={}]".format(
num_cpus),
num_cpus,
):
# Note that it is useful here that the outermost eigenstate object is
# a list, as for certain applications the necessary hilbert space
# dimension can vary with paramvals
eigensystem_mapdata = list(
target_map(
func,
tqdm(
param_vals,
desc="Spectral data",
leave=False,
disable=tqdm_disable,
),
))
eigenvalue_table, eigenstate_table = recast_esys_mapdata(
eigensystem_mapdata)
if subtract_ground:
for param_index, _ in enumerate(param_vals):
eigenvalue_table[param_index] -= eigenvalue_table[param_index][
0]
setattr(self, param_name, previous_paramval)
specdata = SpectrumData(
eigenvalue_table,
self.get_initdata(),
param_name,
param_vals,
state_table=eigenstate_table,
)
if filename:
specdata.filewrite(filename)
return SpectrumData(
eigenvalue_table,
self.get_initdata(),
param_name,
param_vals,
state_table=eigenstate_table,
)
def get_spectrum_vs_paramvals(self,
param_name,
param_vals,
evals_count=6,
subtract_ground=False,
get_eigenstates=False,
filename=None,
num_cpus=settings.NUM_CPUS):
"""Calculates eigenvalues/eigenstates for a varying system parameter, given an array of parameter values.
Returns a `SpectrumData` object with `energy_data[n]` containing eigenvalues calculated for
parameter value `param_vals[n]`.
Parameters
----------
param_name: str
name of parameter to be varied
param_vals: ndarray
parameter values to be plugged in
evals_count: int, optional
number of desired eigenvalues (sorted from smallest to largest) (default value = 6)
subtract_ground: bool, optional
if True, eigenvalues are returned relative to the ground state eigenvalue (default value = False)
get_eigenstates: bool, optional
return eigenstates along with eigenvalues (default value = False)
filename: str, optional
file name if direct output to disk is wanted
num_cpus: int, optional
number of cores to be used for computation (default value: settings.NUM_CPUS)
Returns
-------
SpectrumData object
"""
previous_paramval = getattr(self, param_name)
target_map = get_map_method(num_cpus)
if get_eigenstates:
func = functools.partial(self._esys_for_paramval,
param_name=param_name,
evals_count=evals_count)
with InfoBar(
"Parallel computation of eigenvalues [num_cpus={}]".format(
num_cpus), num_cpus):
eigensystem_mapdata = list(
target_map(
func,
tqdm(param_vals,
desc='Spectral data',
leave=False,
disable=(num_cpus > 1))))
eigenvalue_table, eigenstate_table = recast_esys_mapdata(
eigensystem_mapdata)
else:
func = functools.partial(self._evals_for_paramval,
param_name=param_name,
evals_count=evals_count)
with InfoBar(
"Parallel computation of eigensystems [num_cpus={}]".
format(num_cpus), num_cpus):
eigenvalue_table = list(
target_map(
func,
tqdm(param_vals,
desc='Spectral data',
leave=False,
disable=(num_cpus > 1))))
eigenvalue_table = np.asarray(eigenvalue_table)
eigenstate_table = None
if subtract_ground:
for param_index, _ in enumerate(param_vals):
eigenvalue_table[param_index] -= eigenvalue_table[param_index,
0]
setattr(self, param_name, previous_paramval)
specdata = SpectrumData(eigenvalue_table,
self._get_metadata_dict(),
param_name,
param_vals,
state_table=eigenstate_table)
if filename:
specdata.filewrite(filename)
return SpectrumData(eigenvalue_table,
self._get_metadata_dict(),
param_name,
param_vals,
state_table=eigenstate_table)
