emu-base 2.4.2__py3-none-any.whl → 2.4.4__py3-none-any.whl

emu_base/__init__.py

@@ -4,7 +4,7 @@ from .math.brents_root_finding import find_root_brents
 from .math.krylov_exp import krylov_exp, DEFAULT_MAX_KRYLOV_DIM
 from .jump_lindblad_operators import compute_noise_from_lindbladians
 from .math.matmul import matmul_2x2_with_batched
-from .utils import get_max_rss, apply_measurement_errors, unix_like
+from .utils import get_max_rss, apply_measurement_errors, unix_like, init_logging
 
 __all__ = [
     "__version__",
@@ -19,6 +19,7 @@ __all__ = [
     "DEVICE_COUNT",
     "apply_measurement_errors",
     "unix_like",
+    "init_logging",
 ]
 
-__version__ = "2.4.2"
+__version__ = "2.4.4"

emu_base/jump_lindblad_operators.py

@@ -2,59 +2,91 @@ from pulser.noise_model import NoiseModel
 import torch
 import math
 
+dtype = torch.complex128
+
 
 def get_lindblad_operators(
-    *, noise_type: str, noise_model: NoiseModel
+    *,
+    noise_type: str,
+    noise_model: NoiseModel,
+    interact_type: str = "ising",
+    dim: int = 2,
 ) -> list[torch.Tensor]:
+
     assert noise_type in noise_model.noise_types
 
     if noise_type == "relaxation":
         c = math.sqrt(noise_model.relaxation_rate)
-        return [
-            torch.tensor([[0, c], [0, 0]], dtype=torch.complex128),
-        ]
+        relaxation = torch.zeros(dim, dim, dtype=dtype)
+        relaxation[0, 1] = c
+        return [relaxation]
 
     if noise_type == "dephasing":
         if noise_model.hyperfine_dephasing_rate != 0.0:
             raise NotImplementedError("hyperfine_dephasing_rate is unsupported")
 
         c = math.sqrt(noise_model.dephasing_rate / 2)
-        return [
-            torch.tensor([[-c, 0], [0, c]], dtype=torch.complex128),
-        ]
+        dephasing = torch.zeros(dim, dim, dtype=dtype)
+
+        dephasing[0, 0] = c
+        dephasing[1, 1] = -c
+
+        return [dephasing]
 
     if noise_type == "depolarizing":
         c = math.sqrt(noise_model.depolarizing_rate / 4)
-        return [
-            torch.tensor([[0, c], [c, 0]], dtype=torch.complex128),
-            torch.tensor([[0, 1j * c], [-1j * c, 0]], dtype=torch.complex128),
-            torch.tensor([[-c, 0], [0, c]], dtype=torch.complex128),
-        ]
+        depolarizing_x = torch.zeros(dim, dim, dtype=dtype)
+        depolarizing_x[0, 1] = c
+        depolarizing_x[1, 0] = c
+
+        depolarizing_y = torch.zeros(dim, dim, dtype=dtype)
+        depolarizing_y[0, 1] = torch.tensor(-c * 1.0j, dtype=dtype)
+        depolarizing_y[1, 0] = torch.tensor(c * 1.0j, dtype=dtype)
+
+        depolarizing_z = torch.zeros(dim, dim, dtype=dtype)
+        depolarizing_z[0, 0] = c
+        depolarizing_z[1, 1] = -c
+
+        return [depolarizing_x, depolarizing_y, depolarizing_z]
 
     if noise_type == "eff_noise":
         if not all(
-            isinstance(op, torch.Tensor) and op.shape == (2, 2)
+            isinstance(op, torch.Tensor) and op.shape == (dim, dim)
             for op in noise_model.eff_noise_opers
         ):
-            raise ValueError("Only 2 * 2 effective noise operator matrices are supported")
-
-        return [
-            math.sqrt(rate)
-            * torch.flip(op if isinstance(op, torch.Tensor) else torch.tensor(op), (0, 1))
-            for rate, op in zip(noise_model.eff_noise_rates, noise_model.eff_noise_opers)
-        ]
+            raise ValueError(
+                "Only 2 by 2 or 3 by 3 effective noise operator matrices are "
+                "supported and it should be given as torch tensors "
+            )
+        if interact_type == "ising":
+            return [  # lindblad operators in pulser ising basis
+                math.sqrt(rate) * torch.flip(torch.as_tensor(op), (0, 1))
+                for rate, op in zip(
+                    noise_model.eff_noise_rates, noise_model.eff_noise_opers
+                )
+            ]
+        elif interact_type == "XY":
+            return [  # lindblad operators in pulser XY basis
+                math.sqrt(rate) * torch.as_tensor(op)
+                for rate, op in zip(
+                    noise_model.eff_noise_rates, noise_model.eff_noise_opers
+                )
+            ]
 
     raise ValueError(f"Unknown noise type: {noise_type}")
 
 
-def compute_noise_from_lindbladians(lindbladians: list[torch.Tensor]) -> torch.Tensor:
+def compute_noise_from_lindbladians(
+    lindbladians: list[torch.Tensor], dim: int = 2
+) -> torch.Tensor:
     """
-    Compute the single-qubit Hamiltonian noise term -0.5i∑L†L from all the given lindbladians.
+    Compute the single-qubit Hamiltonian noise term -0.5i∑L†L from all the
+    given lindbladians.
     """
     assert all(
-        lindbladian.shape == (2, 2) for lindbladian in lindbladians
+        lindbladian.shape == (dim, dim) for lindbladian in lindbladians
     ), "Only single-qubit lindblad operators are supported"
 
-    zero = torch.zeros(2, 2, dtype=torch.complex128)
+    zero = torch.zeros(dim, dim, dtype=dtype)
 
     return -0.5j * sum((L.mH @ L for L in lindbladians), start=zero)

emu_base/pulser_adapter.py

@@ -20,7 +20,7 @@ _NON_LINDBLADIAN_NOISE = {"SPAM", "doppler", "amplitude", "detuning", "register"
 
 
 def _get_all_lindblad_noise_operators(
-    noise_model: NoiseModel | None,
+    noise_model: NoiseModel | None, dim: int = 2, interact_type: str = "ising"
 ) -> list[torch.Tensor]:
     if noise_model is None:
         return []
@@ -29,7 +29,12 @@ def _get_all_lindblad_noise_operators(
         op
         for noise_type in noise_model.noise_types
         if noise_type not in _NON_LINDBLADIAN_NOISE
-        for op in get_lindblad_operators(noise_type=noise_type, noise_model=noise_model)
+        for op in get_lindblad_operators(
+            noise_type=noise_type,
+            noise_model=noise_model,
+            dim=dim,
+            interact_type=interact_type,
+        )
     ]
 
 
@@ -150,6 +155,7 @@ class PulserData:
         )
 
         int_type = self.hamiltonian.interaction_type
+        self.dim = self.hamiltonian.dim
         if int_type == "ising":  # for local and global
             self.hamiltonian_type = HamiltonianType.Rydberg
         elif int_type == "XY":
@@ -157,7 +163,9 @@ class PulserData:
         else:
             raise ValueError(f"Unsupported basis: {int_type}")
 
-        self.lindblad_ops = _get_all_lindblad_noise_operators(config.noise_model)
+        self.lindblad_ops = _get_all_lindblad_noise_operators(
+            config.noise_model, dim=self.dim, interact_type=int_type
+        )
         self.has_lindblad_noise: bool = self.lindblad_ops != []
 
         if config.interaction_matrix is not None:

emu_base/utils.py

@@ -2,12 +2,33 @@ from collections import Counter
 import random
 import torch
 import os
+import logging
+import sys
+from pathlib import Path
 
 unix_like = os.name != "nt"
 if unix_like:
     from resource import RUSAGE_SELF, getrusage
 
 
+def init_logging(log_level: int, log_file: Path | None) -> logging.Logger:
+    logger = logging.getLogger("emulators")
+    logger.propagate = False
+
+    handler: logging.Handler
+    if log_file is None:
+        handler = logging.StreamHandler(sys.stdout)
+    else:
+        handler = logging.FileHandler(log_file, mode="w")
+
+    handler.setLevel(log_level)
+    handler.setFormatter(logging.Formatter("%(message)s"))
+    for h in logger.handlers:
+        logger.removeHandler(h)
+    logger.addHandler(handler)
+    return logger
+
+
 def deallocate_tensor(t: torch.Tensor) -> None:
     """
     Free the memory used by a tensor. This is done regardless of the

{emu_base-2.4.2.dist-info → emu_base-2.4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emu-base
-Version: 2.4.2
+Version: 2.4.4
 Summary: Pasqal base classes for emulators
 Project-URL: Documentation, https://pasqal-io.github.io/emulators/
 Project-URL: Repository, https://github.com/pasqal-io/emulators

{emu_base-2.4.2.dist-info → emu_base-2.4.4.dist-info}/RECORD

@@ -1,14 +1,14 @@
-emu_base/__init__.py,sha256=xntCCkVdr3et_zsVcIsr2uEBnvt-gNMNFwstt4p5CM8,725
+emu_base/__init__.py,sha256=D7NkoAkHyN0qILkIdfrzfs5-C2yl381TySMHwEWj14c,759
 emu_base/constants.py,sha256=41LYkKLUCz-oxPbd-j7nUDZuhIbUrnez6prT0uR0jcE,56
-emu_base/jump_lindblad_operators.py,sha256=Y30f8emVFS4Dazljc_Rh4lX9qU4QQY_AxPNahnzcsfY,2101
-emu_base/pulser_adapter.py,sha256=bb529P2tspLgX_EcJxCT4bJjFM8SOIttgsFIznTeN58,6979
-emu_base/utils.py,sha256=OoJ0GjL1K8m9Jq-BeBfmbWuFp9bvwXp8UcI3BMW94Js,2974
+emu_base/jump_lindblad_operators.py,sha256=Wioao_EohYXBrIRZ1yd_qD9K4rPx9_B0NBKKKwiYr18,3033
+emu_base/pulser_adapter.py,sha256=W5e1NLqqrXwCbGAkUdww7DneDaYX981II5chifB89ek,7219
+emu_base/utils.py,sha256=kXfRFq31r_dfLbBC0SHiPpvf7Wll4behd2vqQJsTrVo,3553
 emu_base/math/__init__.py,sha256=6BbIytYV5uC-e5jLMtIErkcUl_PvfSNnhmVFY9Il8uQ,97
 emu_base/math/brents_root_finding.py,sha256=AVx6L1Il6rpPJWrLJ7cn6oNmJyZOPRgEaaZaubC9lsU,3711
 emu_base/math/double_krylov.py,sha256=X16dyCbyzdP7fFK-hmKS03Q-DJtC6TZ8sJrGTJ6akIc,3708
 emu_base/math/krylov_energy_min.py,sha256=iR4hmE0eXptbAg3opikd5d4Zv7dhnDrawH-n_4KG-cc,4009
 emu_base/math/krylov_exp.py,sha256=mGFddVQ8mEbwypbZtnlRPFpi4Nf8JZT6OKLHloIwCDQ,3934
 emu_base/math/matmul.py,sha256=lEAnV0b5z_f1xEA-9p-WXxA8bM3QbShiHdXQ3ZkZFcQ,877
-emu_base-2.4.2.dist-info/METADATA,sha256=Th95_Wj1Za2kd-t_Dh9O2aBZDeWRysncK0jF_AVTKkc,3604
-emu_base-2.4.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-emu_base-2.4.2.dist-info/RECORD,,
+emu_base-2.4.4.dist-info/METADATA,sha256=e_i4b_tVdN2PTfEs12pUYGZgICeNUbAIzKpNAFBlsfU,3604
+emu_base-2.4.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+emu_base-2.4.4.dist-info/RECORD,,