qutip-cuquantum 0.1.0__tar.gz

qutip_cuquantum-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, QuTiP
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

qutip_cuquantum-0.1.0/MANIFEST.in

@@ -0,0 +1,5 @@
+include VERSION
+# pyproject.toml is automatically included in setuptools>=43.0, but we can
+# support back to 36.6 (which added PEP 517 builds) if we're explicit.
+include pyproject.toml
+recursive-include tests *.py

qutip_cuquantum-0.1.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: qutip-cuquantum
+Version: 0.1.0
+Summary: cuQuantum backend for QuTiP
+Author-email: Eric Giguère <qutip-admin@googlegroups.com>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2025, QuTiP
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Homepage, https://qutip.org
+Project-URL: Bug Tracker, https://github.com/qutip/qutip-cuquantum/issues
+Project-URL: Documentation, https://qutip-cuquantum.readthedocs.io/en/latest/
+Keywords: quantum,physics,dynamics,gpu,linear-algebra
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Classifier: Operating System :: Unix
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: qutip>=5.2.1
+Provides-Extra: cuda11
+Requires-Dist: cupy-cuda11x; extra == "cuda11"
+Requires-Dist: cuquantum-python-cu11; extra == "cuda11"
+Provides-Extra: cuda12
+Requires-Dist: cupy-cuda12x; extra == "cuda12"
+Requires-Dist: cuquantum-python-cu12; extra == "cuda12"
+Provides-Extra: tests
+Requires-Dist: pytest>=6.0; extra == "tests"
+Dynamic: license-file
+
+# qutip-cuquantum
+
+Provide cuQuantum's cuDensityMat as a backend for QuTiP.
+
+This backend is specifically designed for simulating **large, composite quantum systems** by performing tensor network contractions on the GPU.
+
+## Installation
+
+qutip-cuquantum is available on pypi.
+
+```
+pip install -U qutip>=5.2.1
+pip install qutip-cuquantum
+```
+
+
+It require cuquantum to be installed at runtime.
+If you have cuda already installed, you can install dependencies with:
+
+```
+pip install qutip-cuquantum[cuda11]
+```
+or
+```
+pip install qutip-cuquantum[cuda12]
+```
+
+If it does not work, you may need to install cuQuantum yourself,
+see [nvidia's documentation](https://docs.nvidia.com/cuda/cuquantum/latest/getting-started/index.html#installing-cuquantum) for installation instruction.
+
+## Usage
+
+In simple case, simply calling `set_as_default` before a qutip script should be sufficient to use the backend common solver:
+
+```
+import qutip_cuquantum
+from cuquantum.densitymat import WorkStream
+
+qutip_cuquantum.set_as_default(WorkStream())
+```
+
+qutip-cuquantum work well to speed-up large simulation using `mesolve` or `sesolve`.
+However this backend is not compatible with advanced qutip solvers (brmesolve, HEOM) and other various feature.

qutip_cuquantum-0.1.0/README.md

@@ -0,0 +1,43 @@
+# qutip-cuquantum
+
+Provide cuQuantum's cuDensityMat as a backend for QuTiP.
+
+This backend is specifically designed for simulating **large, composite quantum systems** by performing tensor network contractions on the GPU.
+
+## Installation
+
+qutip-cuquantum is available on pypi.
+
+```
+pip install -U qutip>=5.2.1
+pip install qutip-cuquantum
+```
+
+
+It require cuquantum to be installed at runtime.
+If you have cuda already installed, you can install dependencies with:
+
+```
+pip install qutip-cuquantum[cuda11]
+```
+or
+```
+pip install qutip-cuquantum[cuda12]
+```
+
+If it does not work, you may need to install cuQuantum yourself,
+see [nvidia's documentation](https://docs.nvidia.com/cuda/cuquantum/latest/getting-started/index.html#installing-cuquantum) for installation instruction.
+
+## Usage
+
+In simple case, simply calling `set_as_default` before a qutip script should be sufficient to use the backend common solver:
+
+```
+import qutip_cuquantum
+from cuquantum.densitymat import WorkStream
+
+qutip_cuquantum.set_as_default(WorkStream())
+```
+
+qutip-cuquantum work well to speed-up large simulation using `mesolve` or `sesolve`.
+However this backend is not compatible with advanced qutip solvers (brmesolve, HEOM) and other various feature.

qutip_cuquantum-0.1.0/VERSION

@@ -0,0 +1 @@
+0.1.0

qutip_cuquantum-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = [
+    "setuptools",
+    "packaging",
+    "wheel",
+    "Cython",
+    "qutip>=5.2.1",
+    "numpy",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "qutip-cuquantum"
+dynamic = ["version"]
+description = "cuQuantum backend for QuTiP"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { file = "LICENSE" }
+keywords = ["quantum", "physics", "dynamics", "gpu", "linear-algebra"]
+authors = [
+  {name = "Eric Giguère", email = "qutip-admin@googlegroups.com"}
+]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering",
+    "Operating System :: Unix",
+]
+dependencies = [
+    "qutip>=5.2.1",
+]
+
+# URLs for your project
+[project.urls]
+Homepage = "https://qutip.org"
+"Bug Tracker" = "https://github.com/qutip/qutip-cuquantum/issues"
+Documentation = "https://qutip-cuquantum.readthedocs.io/en/latest/"
+
+[project.optional-dependencies]
+cuda11 = ["cupy-cuda11x", "cuquantum-python-cu11"]
+cuda12 = ["cupy-cuda12x", "cuquantum-python-cu12"]
+tests = ["pytest>=6.0"]
+
+[project.entry-points."qutip.family"]
+qutip_cuquantum = "qutip_cuquantum.family"
+
+[tool.setuptools]
+packages = { find = { where = ["src"] } }
+package-dir = { "" = "src" }
+
+[tool.pytest.ini_options]
+addopts = "-Werror --strict-config --strict-markers -W ignore::DeprecationWarning"
+testpaths = [
+    "tests",
+]

qutip_cuquantum-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

qutip_cuquantum-0.1.0/setup.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python
+
+import os
+import subprocess
+import sys
+
+# Required third-party imports, must be specified in pyproject.toml.
+import packaging.version
+import setuptools
+from Cython.Build import cythonize
+import qutip
+import numpy
+
+
+def process_options():
+    """
+    Determine all runtime options, returning a dictionary of the results.  The
+    keys are:
+        'rootdir': str
+            The root directory of the setup.  Almost certainly the directory
+            that this setup.py file is contained in.
+        'release': bool
+            Is this a release build (True) or a local development build (False)
+    """
+    options = {}
+    options["rootdir"] = os.path.dirname(os.path.abspath(__file__))
+    options = _determine_version(options)
+    return options
+
+
+def _determine_version(options):
+    """
+    Adds the 'short_version', 'version' and 'release' options.
+
+    Read from the VERSION file to discover the version.  This should be a
+    single line file containing valid Python package public identifier (see PEP
+    440), for example
+      4.5.2rc2
+      5.0.0
+      5.1.1a1
+    We do that here rather than in setup.cfg so we can apply the local
+    versioning number as well.
+    """
+    version_filename = os.path.join(options["rootdir"], "VERSION")
+    with open(version_filename, "r") as version_file:
+        version_string = version_file.read().strip()
+    version = packaging.version.Version(version_string)
+    options["short_version"] = str(version.public)
+    options["release"] = not version.is_devrelease
+    if not options["release"]:
+        # Put the version string into canonical form, if it wasn't already.
+        version_string = str(version)
+        version_string += "+"
+        try:
+            git_out = subprocess.run(
+                ("git", "rev-parse", "--verify", "--short=7", "HEAD"),
+                check=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            git_hash = git_out.stdout.decode(sys.stdout.encoding).strip()
+            version_string += git_hash or "nogit"
+        # CalledProcessError is for if the git command fails for internal
+        # reasons (e.g. we're not in a git repository), OSError is for if
+        # something goes wrong when trying to run git (e.g. it's not installed,
+        # or a permission error).
+        except (subprocess.CalledProcessError, OSError):
+            version_string += "nogit"
+    options["version"] = version_string
+    return options
+
+
+def create_version_py_file(options):
+    """
+    Generate and write out the file version.py, which is used to produce the
+    '__version__' information for the module.  This function will overwrite an
+    existing file at that location.
+    """
+    filename = os.path.join(options["rootdir"], "src", "qutip_cuquantum", "version.py")
+    content = "\n".join(
+        [
+            "# This file is automatically generated during package setup.",
+            f"short_version = '{options['short_version']}'",
+            f"version = '{options['version']}'",
+            f"release = {options['release']}",
+        ]
+    )
+    with open(filename, "w") as file:
+        print(content, file=file)
+
+
+
+def get_ext_modules(options):
+    pyx_file = os.path.join("src", "qutip_cuquantum", "qobjevo.pyx")
+    include_dirs = [
+        numpy.get_include(),
+        os.path.abspath(os.path.join(qutip.core.data.__file__, os.pardir))
+    ]
+    print("*********************************************************************************")
+    print(include_dirs)
+    print(pyx_file)
+    print("*********************************************************************************")
+    ext = setuptools.Extension(
+        name="qutip_cuquantum.qobjevo",
+        sources=[pyx_file],
+        include_dirs=include_dirs,
+        language="c++",
+    )
+
+    return cythonize(ext)
+
+
+if __name__ == "__main__":
+    options = process_options()
+    create_version_py_file(options)
+    # Most of the kwargs to setup are defined in setup.cfg; the only ones we
+    # keep here are ones that we have done some compile-time processing on.
+
+    setuptools.setup(
+        version = options["version"],
+        ext_modules = get_ext_modules(options),
+    )

qutip_cuquantum-0.1.0/src/qutip_cuquantum/__init__.py

@@ -0,0 +1,108 @@
+try:
+    import cupy
+except ImportError as err:
+    raise ImportError("\n".join([
+        "CuPy is not installed or could not be imported.",
+        "Please install the appropriate version for your CUDA toolkit manually.",
+        "For example, for CUDA 12.x, run:",
+        "    pip install cupy-cuda12x",
+        "For other versions, please see the CuPy installation guide",
+        "https://docs.cupy.dev/en/stable/install.html",
+    ])) from err
+
+try:
+    import cuquantum.densitymat
+except ImportError as err:
+    raise ImportError("\n".join([
+        "cuQuantum.densitymat is not installed or could not be imported.",
+        "Please install the appropriate version for your CUDA toolkit manually.",
+        "For example, for CUDA 12.x, run:",
+        "    pip install cuquantum-python-cu12",
+        "For other versions, please see the cuQuantum installation guide:",
+        "https://docs.nvidia.com/cuda/cuquantum/latest/getting-started/index.html",
+    ])) from err
+
+
+import qutip
+from qutip.core.options import QutipOptions
+from .operator import CuOperator
+from .state import CuState
+
+
+# TODO: The split per density is not great
+# Add an operator / state split in qutip?
+qutip.core.data.to.register_group(
+    ['cuDensity'],
+    dense=qutip.core.data.Dense,
+    sparse=CuOperator,
+    diagonal=CuOperator
+)
+
+try:
+    from qutip_cupy import CuPyDense
+
+    def CuOperator_from_CuDense(mat):
+        return CuOperator(mat)
+
+    def CuPyDense_from_CuState(mat):
+        return CuPyDense(mat.to_cupy())
+
+    def CuState_from_CuPyDense(mat):
+        return CuState(mat)
+
+    qutip.core.data.to.add_conversions([
+        (CuState, CuPyDense, CuState_from_CuPyDense),
+        (CuPyDense, CuState, CuPyDense_from_CuState),
+        (CuOperator, CuPyDense, CuOperator_from_CuDense),
+    ])
+
+except ImportError:
+    pass
+
+
+from .qobjevo import CuQobjEvo
+from .ode import Result, CuMCIntegrator
+
+
+class cuDensityOption(QutipOptions):
+    _options = {"ctx": None}
+    _settings_name = "cuDensity"
+    _properties = {}
+
+
+cuDensityOption_instance = cuDensityOption()
+cuDensityOption_instance._set_as_global_default()
+
+
+def set_as_default(ctx: cuquantum.densitymat.WorkStream):
+    """
+    Update qutip's default to use cuQuantum as a backend.
+
+    Parameters
+    ----------
+    ctx: WorkStream
+        A WorkStream instance from cuquantum.density.
+        It can be set with mpi support for multi-gpu simulations.
+    """
+    qutip.settings.cuDensity["ctx"] = ctx
+    qutip.settings.core["default_dtype"] = "cuDensity"
+    qutip.settings.core['numpy_backend'] = cupy
+
+    if True:  # if mpi, how to check from ctx?
+        qutip.settings.core["auto_real_casting"] = False
+
+    qutip.SESolver.solver_options['method'] = "CuVern7"
+    qutip.MESolver.solver_options['method'] = "CuVern7"
+    qutip.MCSolver.solver_options['method'] = "CuVern7"
+
+    qutip.SESolver._resultclass = Result
+    qutip.MESolver._resultclass = Result
+    qutip.MCSolver._trajectory_resultclass = Result
+    qutip.MCSolver._mc_integrator_class = CuMCIntegrator
+
+
+
+# Cleaning the namespace
+# del Result
+# del QutipOptions
+# del qutip

qutip_cuquantum-0.1.0/src/qutip_cuquantum/callable.py

@@ -0,0 +1,118 @@
+from functools import partial
+from cuquantum.densitymat import CPUCallback, DenseOperator
+
+from qutip.core.tensor import _reverse_partial_tensor, tensor
+from qutip.core.superoperator import spre, spost
+from qutip.core.cy._element import _BaseElement, _FuncElement, _MapElement, _ProdElement, _EvoElement, _ConstantElement
+from qutip.core.data import Dia
+from qutip.core import coefficient, Qobj
+
+from . import CuOperator
+
+
+def _hilbert_from_dims(dims):
+    if isinstance(dims[0], list):
+        return dims[0]
+    return dims
+
+
+def wrap_coeff(coeff):
+    return CPUCallback(lambda t, _: coeff(t))
+
+
+def _wrap_callable(func):
+    sample = func(0)
+    shape = sample._dims._get_tensor_shape()
+    perm = sample._dims._get_tensor_perm()
+    num_mode = len(shape) // 2
+    
+    if sample.dtype is Dia and num_mode == 1:
+        dia_matrix = sample.as_scipy()
+        offsets = list(dia_matrix.offsets)
+
+        def wrapped(t, _=None):
+            # TODO: Should we make this a class for pickling?
+            dia_matrix = func(t).as_scipy()
+            arr_shape = (dia_matrix.shape[0], len(offsets))
+            data = np.zeros(arr_shape, dtype=complex)
+
+            for i, offset in enumerate(offsets):
+                end = None if offset == 0 else -abs(offset)
+                data[:end, i] = dia_matrix.diagonal(offset)
+
+            return data
+
+        out = MultidiagonalOperator(wrapped(0), offsets, callback=CPUCallback(wrapped))
+
+    else:
+        if sample.dtype is Dia:
+            print("Callable QobjEvo converted to dense!")
+        
+        def wrapped(t, _=None):
+            # TODO: Should we make this a class for pickling?
+            arr = func(t).full()
+            arr = arr.reshape(*shape)
+            return arr.transpose(*perm)
+
+        out = DenseOperator(wrapped(0), CPUCallback(wrapped))
+
+    return out, num_mode
+
+
+def wrap_funcelement(element, args, dual, hilbert_dims, anti=False):
+    if not isinstance(element, _BaseElement):
+        element = _FuncElement(element, args)
+
+    if isinstance(element, _FuncElement):
+        oper, num_mode = _wrap_callable(element.qobj)
+        out = tensor_product((oper, tuple(range(num_mode)) ), dtype="complex128")
+
+    elif isinstance(element, _MapElement):
+        oper, num_mode = _wrap_callable(element._base.qobj)
+        as_qobj = Qobj( CuOperator(oper), dims=element._base.qobj(0)._dims )
+        for transform in element._transform:
+            as_qobj = transform(as_qobj)
+        if as_qobj.dtype is not CuOperator:
+            oper, num_mode = _wrap_callable(element.qobj)
+            out = tensor_product((oper, tuple(range(num_mode)) ), dtype="complex128")
+        else:
+            coeff = conj(element._coeff) if anti else element._coeff
+            out = as_qobj.data.to_OperatorTerm(dual, hilbert_dims=hilbert_dims) * coeff
+
+    elif isinstance(element, _ProdElement):
+        dims_left = element._left.qobj(0).dims
+        hilbert_left = _hilbert_from_dims(dims_left)
+        left = CuOperator(
+            wrap_funcelement(element._left, None, dual, hilbert_left, element._conj != anti),
+            hilbert_dims=hilbert_left,
+        )
+        dims_right = element._right.qobj(0).dims
+        hilbert_right = _hilbert_from_dims(dims_right)
+        right = CuOperator(
+            wrap_funcelement(element._right, None, dual, hilbert_right, element._conj != anti),
+            hilbert_dims=hilbert_right,
+        )
+        as_qobj = Qobj(left @ right, [dims_left[0], dims_right[1]])
+        for transform in element._transform:
+            as_qobj = transform(as_qobj)
+        
+        if as_qobj.dtype is not CuOperator:
+            oper, num_mode = _wrap_callable(element.qobj)
+            coeff = make_CPUcall( coefficient(element.coeff).conj() ) if anti else make_CPUcall(element.coeff)
+            out = tensor_product((oper, tuple(range(num_mode)) ), dtype="complex128") * coeff
+        else:
+            out = as_qobj.data.to_OperatorTerm(dual, hilbert_dims=hilbert_dims)
+
+    elif isinstance(element, _EvoElement):
+        qobj = element._qobj
+        coeff = make_CPUcall(element._coefficient.conj()) if anti else make_CPUcall(element._coefficient)
+        out = qobj.data.to_OperatorTerm(dual, hilbert_dims=hilbert_dims) * coeff
+
+    elif isinstance(element, _ConstantElement):
+        qobj = element._qobj
+        out = qobj.data.to_OperatorTerm(dual, hilbert_dims=hilbert_dims)
+
+    else:
+        raise NotImplementedError(type(element))
+
+    return out

qutip_cuquantum-0.1.0/src/qutip_cuquantum/family.py

@@ -0,0 +1,8 @@
+"""QuTiP family package entry point."""
+
+from .version import version as full_version
+
+
+def version():
+    """Return information to include in qutip.about()."""
+    return "qutip-cuquantum", full_version