# QuantumCatch: a Python Package for the Analysis and Simulation of Quantum Measurements
by M. Sifft and D. Hägele
The QuantumCatch package is open-source software for simulating and evaluating continuous quantum measurements via
so-called quantum polyspectra. Here we refer to the polyspectra as second to fourth order spectra
(powerspectrum, bispectrum, and 2D cut through trispectrum). The simulation of measurement traces
(integration of the stochastic master equation) is implemented via the QuTiP toolbox whereas the
calculation of polyspectra from Hamiltonians or measurements traces recorded in the lab is performed
as described in [this paper](https://link.aps.org/doi/10.1103/PhysRevB.98.205143) and [this paper](https://arxiv.org/abs/2011.07992) which also shows the utilization of quantum
polyspectra to extract Hamiltonian parameters from a quantum measurement.
The quantum polyspectra approach enable the characterization of very general quantum systems that may include
* Environmental damping
* Measurement backaction (Zeno effect) and arbitrary measurement strength
* Coherent quantum dynamics
* Stochastic in- and out-tunneling
* Single-photon measurements
* Additional detector noise
* Simultaneous measurement of non-commuting observables
* Incorporation of temperatures
* Completely automatic analysis of arbitrary measurement traces
* Covers all limiting case of weak spin noise measurements, strong measurements resulting in quantum jumps, and single photon sampling
[This poster](Examples/Overview_Poster.pdf) provides an overview of the quantum polyspectra approach to quantum system characterization.
Here is a brief summary: The analysis of a continuous measurement record 𝑧(𝑡) poses a fundamental challenge in
quantum measurement theory. Different approaches have been used in the past as records can, e.g., exhibit
predominantly Gaussian noise, telegraph noise, or clicks at random times. This poster summarizes our latest
findings, showing that quantum measurements from all the aforementioned cases can be analyzed in terms of higher-order
temporal correlations of the detector output 𝑧(𝑡) and be related to the Liouvillian of the measured quantum system.
The comparison of temporal correlations via so-called quantum polyspectra is based on expressions derived without
approximation from the stochastic master equation [1] and automated without requiring manual post-processing of
the detector output. This allows for fitting of system parameters such as tunneling rates in a quantum transport
experiment [2]. The very general stochastic master equation approach includes coherent quantum dynamics, environmental
damping, and measurement backaction at arbitrary measurement strength. This enables a systematic evaluation of quantum
measurements from the realms of conventional spin noise spectroscopy, quantum transport experiments, and ultra-weak
measurements with stochastically arriving single photons [3,4]. [1] Hägele et al., PRB 98, 205143 (2018),
[2] Sifft et al., PRR 3, 033123 (2021), [3] Sifft et al. PRA 107, 052203, [4] Sifft et al., arXiv:2310.10464
## Installation
QuantumCatch is available on `pip` and can be installed with
```bash
pip install quantumcatch
```
### Installation of Arrayfire
Besides running on CPU, QuantumCatch offers GPU support for Nvidia and AMD cards. Depending on the hardware used, the
usage of a GPU is highly recommended for quantum systems with more
than about 10 states. A comprehensive installation guide for Linux + NVidia GPU can be found [here](https://github.com/MarkusSifft/QuantumCatch/wiki/Installation-Guide).
For GPU calculations the high performance library Arrayfire is used. The Python wrapper ([see here](https://github.com/arrayfire/arrayfire-python))
is automatically installed when installing SignalSnap, however, [ArrayFire C/C++ libraries](https://arrayfire.com/download) need to be installed separately.
Instructions can be found can be found [here](https://github.com/arrayfire/arrayfire-python) and [here](https://arrayfire.org/docs/installing.htm#gsc.tab=0).
## Documentation
The documentation of the package can be found [here](https://markussifft.github.io/QuantumCatch/).
The package is divided into two parts: the **simulation** module and the **fitting-tools** module.
### Simulation Module
The Simulation Module allows for the integration of the Stochastic Master Equation via the QuTip library. This way
an example measurement trace can be created. Moreover, it allows for the calculation of the theoretical quantum
polyspectra directly from the system Liouvillian.
### Fitting-Tools Module
The Fitting-Tools Module enables a user-friendly characterization of a quantum system in the lab based on the
quantum polyspectra of an experimental continuous quantum measurement. These quantum polyspectra can be calculated
via our [SignalSnap](https://github.com/MarkusSifft/SignalSnap) package. After providing a model Liouvillian with
one or more variable parameters, these parameters are estimated by fitting the theoretical model prediction of the
polyspectra to their measured counterparts.
### Example: Continuous Measurement of a Qunatum Dot's Occupation
Here we are demonstrating how to simulate a simple quantum point
contact measurement of the charge state of a quantum dot. First we have to
import the QuantumCatch package. We will also import QuTip and NumPy.
The analysis and generation module are imported automatically.
```python
import quantumcatch as qc
import numpy as np
from qutip import *
```
Next, we are going to define the quantum dot system. The system has a Hamiltonian
of $\mathcal{H} = 0$. The tunneling of electrons into and from the quantum dot
and the measurement are modelled via Lindbladian damping terms
while the measurement gets an additional backaction as defined in the
stochastic master equation:
Let's see how this system is implemented for QuantumCatch using QuTip functions. First we are going to
define the operators:
```python
dot_levels = 2
a = destroy(dot_levels)
n = a.dag() * a
rho_0 = ket2dm(basis(dot_levels, 0)) + ket2dm(basis(dot_levels, 1))
rho_0 /= np.trace(rho_0)
H = 0 * n
```
Then we are going to define the initial density matrix of the quantum dot. Here we are starting in a superposition of
full and empty:
```python
rho_0 = ket2dm(basis(dot_levels, 0)) + ket2dm(basis(dot_levels, 1))
rho_0 /= np.trace(rho_0)
```
By defining the tunneling rate and measurement strength we are also setting the units of time. Here we are choosing
ms so the rates will be given in kHz.
```python
beta = 5 # in sqrt(kHz)
gamma_out = 0.5 # in kHz
gamma_in = 0.5 # in kHz
```
Now we have to add damping (c_ops) and measurement terms (sc_ops). We begin by defining the damping/measurement strength
$\gamma$ and $\beta$ choosing the name of the corresponding operator as key an the dictionary:
```python
c_measure_strength = {
'a': gamma_out**0.5,
'a_d': gamma_in**0.5,
}
sc_measure_strength = {
'n': beta
}
```
Afterward we define the damping and measurement operator in QuTiP fashion:
```python
c_ops = {
'a': a,
'a_d': a.dag(),
}
sc_ops = {
'n': n,
}
```
For the calculation of the observable, we are also defining the operators with which the expectation
values are calculated:
```python
e_ops = {
'n': n,
}
```
The System is now ready to be initialized as follows:
```python
system = qc.System(H, rho_0, c_ops, sc_ops, e_ops, c_measure_strength, sc_measure_strength)
```
To run the simulation we simply have to define the desired time steps. Note that especially during a
strong measurement narrow time steps should be chosen. The calc_trnasient function has many options. Please refer to
the [docs](https://markussifft.github.io/QuantumCatch/).
```python
t_start = 0
t_stop = int(4e1)
n_steps = int(10e3)
t = np.linspace(t_start, t_stop, n_steps)
res = system.calc_transient(t, seed=None, _solver='milstein', _normalize=False)
```
The result can be visualized by providing a list of view operators as follows:
```python
view_ops = {'n':1}
system.plot_transient(view_ops)
```
The corresponding quantum polyspectra can be calculated easily via `calculate_spectrum` function. Refer to the
documentation for the option of this function. For example, here the usage of the GPU can be enabled setting `enable_gpu=True`.
```python
f_start = 0
f_stop = 2
n_points = 200
fs = np.linspace(f_start, f_stop, n_points)
measure_op = 'n'
spec = system.calculate_spectrum(fs, order_in=[1,2,3,4], measure_op=measure_op)
```
The polyspectra can be plotted with the `plot` method:
```python
fig = system.plot()
```
### Example: From Quantum Polyspectra to the Model Liouvillian
We begin with formulating a model quantum system using standard QuTiP functions.
```python
import quantumcatch as qc
import numpy as np
from qutip import *
```
The system has to by defined as a function (here `set_system`) that takes in an array of variable
parameters. We will define the parameters soon, here you simply use the ´params´ dictionary
with you own keys of choice (here `gamma_in`, `gamma_out`, and `beta`). These parameters will
be determined by the fitting routine.
```python
def set_system(params):
# ------ Operators and Hamiltonian -----
dot_levels = 2
a = destroy(dot_levels)
n = a.dag() * a
rho_0 = ket2dm(basis(dot_levels, 0)) + ket2dm(basis(dot_levels, 1))
rho_0 /= np.trace(rho_0)
H = 0 * n
# ------ System Parameters ------
c_measure_strength = {
'a': params['gamma_out']**0.5,
'a_d': params['gamma_in']**0.5,
}
sc_measure_strength = {
'n': params['beta']
}
c_ops = {
'a': a,
'a_d': a.dag(),
}
sc_ops = {
'n': n,
}
e_ops = {
'n': n,
}
system = qc.System(H, rho_0, c_ops, sc_ops, e_ops, c_measure_strength, sc_measure_strength)
return system, sc_ops, sc_measure_strength
```
With this parameterize system and the name of our measurement operator, we now create a fit object:
```python
m_op = 'n'
system_fit = qc.FitSystem(set_system, m_op)
```
Now, we can define the parameters with their starting values and bounds in lmfit fashion.
Assuming that the path leads to spectra calculated and saved with the SignalSnap library,
the fit routine is started with the `complete_fit` function. Refer to the documentation
for all possible function parameters.
```python
parameter = {'gamma_in':[300, 0, 1e5, True],
'gamma_out': [700, 0, 1e5, True],
'beta': [1, 0, 1e12, True],
'c': [0, -1e12, 1e12, True]}
path = 'example_data/polyspectra_for_fit_example.pkl'
out = system_fit.complete_fit(path, parameter, method='least_squares', xtol=1e-8, ftol=1e-8, fit_modus='resolution_based',
fit_orders=(1,2,3,4))
```
This figure presents a comprehensive set of nine plots designed to evaluate the quality of the fit. The plots are arranged in a 3x3 grid and are interpreted as follows:
- (0,0): Depicts the first-order spectrum, S1, which is proportional to the mean of the measurement. The experimental S1 trace is displayed in blue, accompanied by its 3σ (three standard deviations) error. The fitted S1 is overlaid in orange.
- (0,1): Illustrates both the experimental and theoretical power spectra.
- (0,2): Presents the relative error between the experimental and theoretical power spectra, normalized to the experimental power spectrum, as a blue line. This line can be compared to the 3σ error of the power spectra values.
- (1,0): Displays the theoretical (upper left triangle) and experimental (lower right triangle) bispectra. This combined representation is facilitated by the symmetry properties of the bispectrum, with the diagonal serving as a symmetry axis.
- (1,1): Shows the relative error between the experimental and theoretical bispectra, normalized to the experimental bispectrum. A pixel is colored green when the difference between the experimental and theoretical bispectra is less than the 3σ error of the spectral values.
- (1,2): Features experimental and theoretical bispectral values along the axes (ω1, 0) and the diagonal, accompanied by a 3σ error band.
- (2,0) to (2,2): These plots mirror the type of plots shown for the bispectrum, but now with the trispectrum.
Each plot provides a unique perspective on the data, collectively offering a robust assessment of the fit's accuracy.
## Support
The development of the QunatumCatch package is supported by the working group Spectroscopy of Condensed Matter
of the Faculty of Physics and Astronomy at the Ruhr University Bochum.
## Dependencies
For the package multiple libraries are used for the numerics and displaying the results:
* Numpy
* Matplotlib
* H5py
* ArrayFire
* Numba
* SciPy
* Tqdm
* Plotly
* Psutil
* Cachetools
* Signalsnap
* Pandas
* Lmfit
* IPyWidgets
Raw data
{
"_id": null,
"home_page": null,
"name": "QuantumCatch",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.7",
"maintainer_email": null,
"keywords": "analysis, continuous quantum measurement, quantum measurement, quantum polyspectra, signal processing, spectra",
"author": null,
"author_email": "Markus Sifft <markus.sifft@rub.de>",
"download_url": "https://files.pythonhosted.org/packages/fa/7c/7fe7c46bb0589f75a172b66a084c809bf8af174811a4727c02812615060f/quantumcatch-0.2.3.tar.gz",
"platform": null,
"description": "# QuantumCatch: a Python Package for the Analysis and Simulation of Quantum Measurements \nby M. Sifft and D. H\u00e4gele\n\nThe QuantumCatch package is open-source software for simulating and evaluating continuous quantum measurements via \nso-called quantum polyspectra. Here we refer to the polyspectra as second to fourth order spectra \n(powerspectrum, bispectrum, and 2D cut through trispectrum). The simulation of measurement traces \n(integration of the stochastic master equation) is implemented via the QuTiP toolbox whereas the \ncalculation of polyspectra from Hamiltonians or measurements traces recorded in the lab is performed \nas described in [this paper](https://link.aps.org/doi/10.1103/PhysRevB.98.205143) and [this paper](https://arxiv.org/abs/2011.07992) which also shows the utilization of quantum \npolyspectra to extract Hamiltonian parameters from a quantum measurement.\n\nThe quantum polyspectra approach enable the characterization of very general quantum systems that may include\n* Environmental damping\n* Measurement backaction (Zeno effect) and arbitrary measurement strength\n* Coherent quantum dynamics\n* Stochastic in- and out-tunneling\n* Single-photon measurements\n* Additional detector noise\n* Simultaneous measurement of non-commuting observables\n* Incorporation of temperatures\n* Completely automatic analysis of arbitrary measurement traces\n* Covers all limiting case of weak spin noise measurements, strong measurements resulting in quantum jumps, and single photon sampling\n\n[This poster](Examples/Overview_Poster.pdf) provides an overview of the quantum polyspectra approach to quantum system characterization. \nHere is a brief summary: The analysis of a continuous measurement record \ud835\udc67(\ud835\udc61) poses a fundamental challenge in \nquantum measurement theory. Different approaches have been used in the past as records can, e.g., exhibit \npredominantly Gaussian noise, telegraph noise, or clicks at random times. This poster summarizes our latest \nfindings, showing that quantum measurements from all the aforementioned cases can be analyzed in terms of higher-order \ntemporal correlations of the detector output \ud835\udc67(\ud835\udc61) and be related to the Liouvillian of the measured quantum system. \nThe comparison of temporal correlations via so-called quantum polyspectra is based on expressions derived without \napproximation from the stochastic master equation [1] and automated without requiring manual post-processing of \nthe detector output. This allows for fitting of system parameters such as tunneling rates in a quantum transport \nexperiment [2]. The very general stochastic master equation approach includes coherent quantum dynamics, environmental\ndamping, and measurement backaction at arbitrary measurement strength. This enables a systematic evaluation of quantum \nmeasurements from the realms of conventional spin noise spectroscopy, quantum transport experiments, and ultra-weak \nmeasurements with stochastically arriving single photons [3,4]. [1] H\u00e4gele et al., PRB 98, 205143 (2018), \n[2] Sifft et al., PRR 3, 033123 (2021), [3] Sifft et al. PRA\u00a0107, 052203, [4] Sifft et al., arXiv:2310.10464\n\n\n## Installation\nQuantumCatch is available on `pip` and can be installed with \n```bash\npip install quantumcatch\n```\n\n### Installation of Arrayfire\nBesides running on CPU, QuantumCatch offers GPU support for Nvidia and AMD cards. Depending on the hardware used, the\nusage of a GPU is highly recommended for quantum systems with more \nthan about 10 states. A comprehensive installation guide for Linux + NVidia GPU can be found [here](https://github.com/MarkusSifft/QuantumCatch/wiki/Installation-Guide). \nFor GPU calculations the high performance library Arrayfire is used. The Python wrapper ([see here](https://github.com/arrayfire/arrayfire-python)) \nis automatically installed when installing SignalSnap, however, [ArrayFire C/C++ libraries](https://arrayfire.com/download) need to be installed separately. \nInstructions can be found can be found [here](https://github.com/arrayfire/arrayfire-python) and [here](https://arrayfire.org/docs/installing.htm#gsc.tab=0).\n\n## Documentation\nThe documentation of the package can be found [here](https://markussifft.github.io/QuantumCatch/). \nThe package is divided into two parts: the **simulation** module and the **fitting-tools** module. \n### Simulation Module\nThe Simulation Module allows for the integration of the Stochastic Master Equation via the QuTip library. This way\nan example measurement trace can be created. Moreover, it allows for the calculation of the theoretical quantum \npolyspectra directly from the system Liouvillian.\n### Fitting-Tools Module\nThe Fitting-Tools Module enables a user-friendly characterization of a quantum system in the lab based on the \nquantum polyspectra of an experimental continuous quantum measurement. These quantum polyspectra can be calculated\nvia our [SignalSnap](https://github.com/MarkusSifft/SignalSnap) package. After providing a model Liouvillian with\none or more variable parameters, these parameters are estimated by fitting the theoretical model prediction of the \npolyspectra to their measured counterparts.\n\n### Example: Continuous Measurement of a Qunatum Dot's Occupation\nHere we are demonstrating how to simulate a simple quantum point \ncontact measurement of the charge state of a quantum dot. First we have to \nimport the QuantumCatch package. We will also import QuTip and NumPy.\nThe analysis and generation module are imported automatically.\n\n```python\nimport quantumcatch as qc\nimport numpy as np\nfrom qutip import *\n```\n\nNext, we are going to define the quantum dot system. The system has a Hamiltonian \nof $\\mathcal{H} = 0$. The tunneling of electrons into and from the quantum dot \nand the measurement are modelled via Lindbladian damping terms \nwhile the measurement gets an additional backaction as defined in the \nstochastic master equation:\n\n\n\nLet's see how this system is implemented for QuantumCatch using QuTip functions. First we are going to\ndefine the operators:\n\n```python\ndot_levels = 2\na = destroy(dot_levels)\nn = a.dag() * a\nrho_0 = ket2dm(basis(dot_levels, 0)) + ket2dm(basis(dot_levels, 1)) \nrho_0 /= np.trace(rho_0)\nH = 0 * n\n```\n\nThen we are going to define the initial density matrix of the quantum dot. Here we are starting in a superposition of \nfull and empty:\n\n```python\nrho_0 = ket2dm(basis(dot_levels, 0)) + ket2dm(basis(dot_levels, 1)) \nrho_0 /= np.trace(rho_0)\n```\n\nBy defining the tunneling rate and measurement strength we are also setting the units of time. Here we are choosing\nms so the rates will be given in kHz. \n\n```python\nbeta = 5 # in sqrt(kHz)\ngamma_out = 0.5 # in kHz\ngamma_in = 0.5 # in kHz\n```\n\nNow we have to add damping (c_ops) and measurement terms (sc_ops). We begin by defining the damping/measurement strength\n$\\gamma$ and $\\beta$ choosing the name of the corresponding operator as key an the dictionary:\n\n```python\nc_measure_strength = {\n 'a': gamma_out**0.5,\n 'a_d': gamma_in**0.5,\n}\n\nsc_measure_strength = {\n 'n': beta\n}\n```\n\nAfterward we define the damping and measurement operator in QuTiP fashion:\n\n```python\nc_ops = {\n 'a': a,\n 'a_d': a.dag(),\n}\n\nsc_ops = {\n 'n': n,\n}\n```\n\nFor the calculation of the observable, we are also defining the operators with which the expectation \nvalues are calculated:\n\n```python\ne_ops = {\n 'n': n,\n}\n```\nThe System is now ready to be initialized as follows:\n```python\nsystem = qc.System(H, rho_0, c_ops, sc_ops, e_ops, c_measure_strength, sc_measure_strength)\n```\n\nTo run the simulation we simply have to define the desired time steps. Note that especially during a \nstrong measurement narrow time steps should be chosen. The calc_trnasient function has many options. Please refer to \nthe [docs](https://markussifft.github.io/QuantumCatch/). \n\n```python\nt_start = 0\nt_stop = int(4e1)\nn_steps = int(10e3)\nt = np.linspace(t_start, t_stop, n_steps)\nres = system.calc_transient(t, seed=None, _solver='milstein', _normalize=False)\n```\nThe result can be visualized by providing a list of view operators as follows:\n\n```python\nview_ops = {'n':1}\nsystem.plot_transient(view_ops)\n```\n\n\nThe corresponding quantum polyspectra can be calculated easily via `calculate_spectrum` function. Refer to the \ndocumentation for the option of this function. For example, here the usage of the GPU can be enabled setting `enable_gpu=True`.\n\n```python\nf_start = 0\nf_stop = 2\nn_points = 200\nfs = np.linspace(f_start, f_stop, n_points)\n\nmeasure_op = 'n'\n\nspec = system.calculate_spectrum(fs, order_in=[1,2,3,4], measure_op=measure_op)\n```\n\nThe polyspectra can be plotted with the `plot` method:\n\n```python\nfig = system.plot()\n```\n\n\n\n### Example: From Quantum Polyspectra to the Model Liouvillian\n\nWe begin with formulating a model quantum system using standard QuTiP functions.\n\n```python\nimport quantumcatch as qc\nimport numpy as np\nfrom qutip import *\n```\n\nThe system has to by defined as a function (here `set_system`) that takes in an array of variable \nparameters. We will define the parameters soon, here you simply use the \u00b4params\u00b4 dictionary \nwith you own keys of choice (here `gamma_in`, `gamma_out`, and `beta`). These parameters will\nbe determined by the fitting routine.\n\n```python\ndef set_system(params):\n # ------ Operators and Hamiltonian -----\n dot_levels = 2\n a = destroy(dot_levels)\n n = a.dag() * a\n rho_0 = ket2dm(basis(dot_levels, 0)) + ket2dm(basis(dot_levels, 1)) \n rho_0 /= np.trace(rho_0)\n H = 0 * n\n \n # ------ System Parameters ------\n c_measure_strength = {\n 'a': params['gamma_out']**0.5,\n 'a_d': params['gamma_in']**0.5,\n }\n \n sc_measure_strength = {\n 'n': params['beta']\n }\n \n c_ops = {\n 'a': a,\n 'a_d': a.dag(),\n }\n \n sc_ops = {\n 'n': n,\n }\n \n e_ops = {\n 'n': n,\n }\n\n system = qc.System(H, rho_0, c_ops, sc_ops, e_ops, c_measure_strength, sc_measure_strength)\n \n return system, sc_ops, sc_measure_strength\n```\n\nWith this parameterize system and the name of our measurement operator, we now create a fit object:\n\n```python\nm_op = 'n'\nsystem_fit = qc.FitSystem(set_system, m_op)\n```\n\nNow, we can define the parameters with their starting values and bounds in lmfit fashion.\nAssuming that the path leads to spectra calculated and saved with the SignalSnap library,\nthe fit routine is started with the `complete_fit` function. Refer to the documentation \nfor all possible function parameters.\n\n```python\nparameter = {'gamma_in':[300, 0, 1e5, True],\n 'gamma_out': [700, 0, 1e5, True],\n 'beta': [1, 0, 1e12, True],\n 'c': [0, -1e12, 1e12, True]}\n \npath = 'example_data/polyspectra_for_fit_example.pkl' \nout = system_fit.complete_fit(path, parameter, method='least_squares', xtol=1e-8, ftol=1e-8, fit_modus='resolution_based',\n fit_orders=(1,2,3,4))\n```\n\n\n\nThis figure presents a comprehensive set of nine plots designed to evaluate the quality of the fit. The plots are arranged in a 3x3 grid and are interpreted as follows:\n\n- (0,0): Depicts the first-order spectrum, S1, which is proportional to the mean of the measurement. The experimental S1 trace is displayed in blue, accompanied by its 3\u03c3 (three standard deviations) error. The fitted S1 is overlaid in orange.\n\n- (0,1): Illustrates both the experimental and theoretical power spectra.\n\n- (0,2): Presents the relative error between the experimental and theoretical power spectra, normalized to the experimental power spectrum, as a blue line. This line can be compared to the 3\u03c3 error of the power spectra values.\n\n- (1,0): Displays the theoretical (upper left triangle) and experimental (lower right triangle) bispectra. This combined representation is facilitated by the symmetry properties of the bispectrum, with the diagonal serving as a symmetry axis.\n\n- (1,1): Shows the relative error between the experimental and theoretical bispectra, normalized to the experimental bispectrum. A pixel is colored green when the difference between the experimental and theoretical bispectra is less than the 3\u03c3 error of the spectral values.\n\n- (1,2): Features experimental and theoretical bispectral values along the axes (\u03c91, 0) and the diagonal, accompanied by a 3\u03c3 error band.\n\n- (2,0) to (2,2): These plots mirror the type of plots shown for the bispectrum, but now with the trispectrum. \n\nEach plot provides a unique perspective on the data, collectively offering a robust assessment of the fit's accuracy.\n\n\n## Support\nThe development of the QunatumCatch package is supported by the working group Spectroscopy of Condensed Matter \nof the Faculty of Physics and Astronomy at the Ruhr University Bochum.\n\n## Dependencies\nFor the package multiple libraries are used for the numerics and displaying the results:\n* Numpy\n* Matplotlib\n* H5py\n* ArrayFire\n* Numba\n* SciPy\n* Tqdm\n* Plotly\n* Psutil\n* Cachetools\n* Signalsnap\n* Pandas\n* Lmfit\n* IPyWidgets\n\n",
"bugtrack_url": null,
"license": null,
"summary": "Package for the simulation and evaluation of continuous quantum measurements",
"version": "0.2.3",
"project_urls": {
"Bug Tracker": "https://github.com/MarkusSifft/QuantumCatch/issues",
"Homepage": "https://github.com/MarkusSifft/QuantumCatch"
},
"split_keywords": [
"analysis",
" continuous quantum measurement",
" quantum measurement",
" quantum polyspectra",
" signal processing",
" spectra"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "f399de9a11f30ba377c15cae0fcef8cdb5d1071ecb5f9fee87831909063fcea5",
"md5": "cee565242cc90547efbeacecd00b2a98",
"sha256": "19b2c522caa3454849f0c1099772c8bba9386f29e42fc38a65c82d6d0b1d871d"
},
"downloads": -1,
"filename": "quantumcatch-0.2.3-py3-none-any.whl",
"has_sig": false,
"md5_digest": "cee565242cc90547efbeacecd00b2a98",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.7",
"size": 46761,
"upload_time": "2024-05-08T13:54:02",
"upload_time_iso_8601": "2024-05-08T13:54:02.407350Z",
"url": "https://files.pythonhosted.org/packages/f3/99/de9a11f30ba377c15cae0fcef8cdb5d1071ecb5f9fee87831909063fcea5/quantumcatch-0.2.3-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "fa7c7fe7c46bb0589f75a172b66a084c809bf8af174811a4727c02812615060f",
"md5": "dc2aac2f47c96aafb5df83d956f573ad",
"sha256": "22615d1c7b5bb980e38c4a800a9783b8ae10293a2db79a00203b1e459efa00a5"
},
"downloads": -1,
"filename": "quantumcatch-0.2.3.tar.gz",
"has_sig": false,
"md5_digest": "dc2aac2f47c96aafb5df83d956f573ad",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.7",
"size": 30287842,
"upload_time": "2024-05-08T13:54:18",
"upload_time_iso_8601": "2024-05-08T13:54:18.392292Z",
"url": "https://files.pythonhosted.org/packages/fa/7c/7fe7c46bb0589f75a172b66a084c809bf8af174811a4727c02812615060f/quantumcatch-0.2.3.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-05-08 13:54:18",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "MarkusSifft",
"github_project": "QuantumCatch",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"lcname": "quantumcatch"
}
JSON
