simcats 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

simcats/__init__.py

@@ -1,5 +1,4 @@
-"""
-SimCATS is a python framework for simulating charge stability diagrams (CSDs) typically measured during the tuning
+"""SimCATS is a python framework for simulating charge stability diagrams (CSDs) typically measured during the tuning
 process of qubits.
 """
 
@@ -7,4 +6,4 @@ from ._simulation import Simulation
 from ._default_configs import default_configs
 
 __all__ = ["Simulation", "default_configs"]
-__version__ = "1.0.0"
+__version__ = "1.2.0"

simcats/distortions/_dot_jumps.py

@@ -156,11 +156,16 @@ class OccupationDotJumps(OccupationDistortionInterface):
             numpy array with the axis mapping to the CSD axis.
 
         """
-        if not bool(self.rng.binomial(1, self.ratio)):
-            self.__activated = False
+        if freeze and not self.__activated:
             return occupations, lead_transitions
-        else:
-            self.__activated = True
+
+        # only resample activation if not frozen
+        if not freeze:
+            if not bool(self.rng.binomial(1, self.ratio)):
+                self.__activated = False
+                return occupations, lead_transitions
+            else:
+                self.__activated = True
 
         resolution = occupations.shape[0:2]
         if freeze:
@@ -467,8 +472,8 @@ class OccupationDotJumps(OccupationDistortionInterface):
                     volt_limits_g2=volt_limits_g2,
                     resolution=(max_jump, occupation.shape[0]) if max_jump > 1 else (occupation.shape[0]),
                 )
-                left_occupation = np.reshape(left_occupation, (occupation.shape[1], max_jump, 2))
-                left_charge_transitions = np.reshape(left_charge_transitions, (occupation.shape[1], max_jump))
+                left_occupation = np.reshape(left_occupation, (occupation.shape[0], max_jump, 2))
+                left_charge_transitions = np.reshape(left_charge_transitions, (occupation.shape[0], max_jump))
                 occupation_stacked = np.hstack((left_occupation, occupation))
                 if lead_transitions is not None:
                     total_charge_transitions_stacked = np.hstack((left_charge_transitions, lead_transitions))

simcats/ideal_csd/__init__.py

@@ -3,6 +3,6 @@ SimCATS subpackage containing all functionalities related to the simulation of i
 """
 
 from simcats.ideal_csd._ideal_csd_interface import IdealCSDInterface
-from simcats.ideal_csd.geometric._ideal_csd_geometric import IdealCSDGeometric
+from simcats.ideal_csd.geometric._ideal_csd_geometric_class import IdealCSDGeometric
 
 __all__ = ["IdealCSDInterface", "IdealCSDGeometric"]

simcats/ideal_csd/geometric/_ideal_csd_geometric.py

@@ -8,7 +8,6 @@ from typing import List, Tuple, Union
 
 import numpy as np
 
-from simcats.ideal_csd import IdealCSDInterface
 from simcats.ideal_csd.geometric import (
     calculate_all_bezier_anchors,
     generate_lead_transition_mask_1d,
@@ -20,150 +19,6 @@ from simcats.ideal_csd.geometric import initialize_tct_functions
 __all__ = []
 
 
-class IdealCSDGeometric(IdealCSDInterface):
-    """Geometric simulation approach implementation of the IdealCSDInterface."""
-
-    def __init__(
-        self,
-        tct_params: List[np.ndarray],
-        rotation: float = -np.pi / 4,
-        lut_entries: Union[int, None] = None,
-        cdf_type: str = "sigmoid",
-        cdf_gamma_factor: Union[float, None] = None,
-    ) -> None:
-        """Initializes an object of the class for the geometric simulation approach which is based on total charge
-        transitions (TCTs).
-
-        Args:
-            tct_params (List[np.ndarray]): List containing a numpy array with parameters for every TCT in the CSD.
-                Each array contains all required parameters to describe the TCT form. \n
-                The parameters for a TCT are: \n
-                [0] = length left (in x-/voltage-space, not number of points) \n
-                [1] = length right (in x-/voltage-space, not number of points) \n
-                [2] = gradient left (in voltages) \n
-                [3] = gradient right (in voltages) \n
-                [4] = start position x (bezier curve leftmost point) (in x-/voltage-space, not number of points) \n
-                [5] = start position y (bezier curve leftmost point) (in x-/voltage-space, not number of points) \n
-                [6] = end position x (bezier curve rightmost point) (in x-/voltage-space, not number of points) \n
-                [7] = end position y (bezier curve rightmost point) (in x-/voltage-space, not number of points)
-            rotation (float): Float value defining the rotation to be applied to the TCT (which is usually represented
-                with the tct_params rotated by 45 degrees). Default is -np.pi/4.
-            lut_entries (Union[int, None]): Number of samples for the lookup-table for bezier curves. If this is not None, a
-                lookup-table will be used to evaluate the points on the bezier curves, else they are solved explicitly.
-                Using a lookup-table speeds up the calculation at the possible cost of accuracy. Default is None.
-            cdf_type (str): Name of the type of cumulative distribution function (CDF) to be used. Can be either
-                "cauchy" or "sigmoid". Default is "sigmoid".
-            cdf_gamma_factor (Union[float, None]): The factor used for the calculation of the gamma values of the CDF. If set to None
-                (=default) the default values for the selected cdf_type are used (2.2 for sigmoid, 6.15 for cauchy).
-                Default is None. \n
-                Gamma is calculated as follows: \n
-                gamma = width_bezier_curve / cdf_gamma_factor
-        """
-        self.tct_params = tct_params
-        self.rotation = rotation
-        self.lut_entries = lut_entries
-        self.cdf_type = cdf_type
-        self.cdf_gamma_factor = cdf_gamma_factor
-
-    @property
-    def tct_params(self) -> List[np.ndarray]:
-        """List containing a numpy array with parameters for every TCT in the CSD. Each array contains all required
-        parameters to describe the TCT form.
-        """
-        return self.__tct_params
-
-    @tct_params.setter
-    def tct_params(self, wave_params: list):
-        self.__tct_params = wave_params
-
-    @property
-    def rotation(self) -> float:
-        """Float value defining the rotation to be applied to the TCT (which is usually represented with the tct_params
-        rotated by 45 degrees).
-        """
-        return self.__rotation
-
-    @rotation.setter
-    def rotation(self, rotation: float) -> None:
-        self.__rotation = rotation
-
-    @property
-    def lut_entries(self) -> Union[int, None]:
-        """Number of samples for the lookup-table for bezier curves. If this is not None, a lookup-table will be used to
-        evaluate the points on the bezier curves, else they are solved explicitly.
-        """
-        return self.__lut_entries
-
-    @lut_entries.setter
-    def lut_entries(self, lut_entries: Union[int, None]):
-        self.__lut_entries = lut_entries
-
-    @property
-    def cdf_type(self) -> str:
-        """Name of the type of cumulative distribution function (CDF) to be used."""
-        return self.__cdf_type
-
-    @cdf_type.setter
-    def cdf_type(self, cdf_type: str) -> None:
-        self.__cdf_type = cdf_type
-
-    @property
-    def cdf_gamma_factor(self) -> Union[float, None]:
-        """The factor used for the calculation of the gamma values of the CDF. If set to None (=default) the default values
-        for the selected cdf_type are used (2.2 for sigmoid, 6.15 for cauchy).
-        """
-        return self.__cdf_gamma_factor
-
-    @cdf_gamma_factor.setter
-    def cdf_gamma_factor(self, cdf_gamma_factor: Union[float, None]):
-        self.__cdf_gamma_factor = cdf_gamma_factor
-
-    def get_csd_data(
-        self,
-        volt_limits_g1: np.ndarray,
-        volt_limits_g2: np.ndarray,
-        resolution: Union[int, np.ndarray] = np.array([100, 100]),
-    ) -> Tuple[np.ndarray, np.ndarray]:
-        """Retrieve ideal data (occupation numbers and a lead transition mask) for given gate voltages.
-
-        Args:
-            volt_limits_g1 (np.ndarray): Voltage sweep range of (plunger) gate 1 (second-/x-axis). \n
-                Example: \n
-                [min_V1, max_V1]
-            volt_limits_g2 (np.ndarray): Voltage sweep range of (plunger) gate 2 (first-/y-axis). \n
-                Example: \n
-                [min_V2, max_V2]
-            resolution (np.ndarray): Desired resolution (in pixels) for the gates. If only one value is supplied, a 1D
-                sweep is performed. Then, both gates are swept simultaneously. Default is np.array([100, 100]). \n
-                Example: \n
-                [res_g1, res_g2]
-
-        Returns:
-            Tuple[np.ndarray, np.ndarray]: Occupation numbers and lead transition mask (in our case: total charge
-            transitions). The occupation numbers are stored in a 3-dimensional numpy array. The first two dimensions map
-            to the axis of the CSD, while the third dimension indicates the dot of the corresponding occupation value.
-            The label mask for the lead-to-dot transitions is stored in a 2-dimensional numpy array with the axis
-            mapping to the CSD axis.
-
-        """
-        return ideal_csd_geometric(
-            tct_params=self.__tct_params,
-            volt_limits_g1=volt_limits_g1,
-            volt_limits_g2=volt_limits_g2,
-            resolution=resolution,
-            rotation=self.__rotation,
-            lut_entries=self.__lut_entries,
-            cdf_type=self.__cdf_type,
-            cdf_gamma_factor=self.__cdf_gamma_factor,
-        )
-
-    def __repr__(self):
-        return (
-            self.__class__.__name__
-            + f"(tct_params={self.__tct_params}, rotation={self.__rotation}, lut_entries={self.__lut_entries}, cdf_type='{self.__cdf_type}', cdf_gamma_factor={self.__cdf_gamma_factor})"
-        )
-
-
 def ideal_csd_geometric(
     tct_params: List[np.ndarray],
     volt_limits_g1: np.ndarray,

simcats/ideal_csd/geometric/_ideal_csd_geometric_class.py

@@ -0,0 +1,158 @@
+"""This module contains the required functionalities to generate ideal CSD data using supplied total charge
+transitions (TCTs), voltage ranges and a desired resolution. It also implements the IdealCSDInterface.
+
+@author: f.hader
+"""
+
+from typing import List, Tuple, Union
+
+import numpy as np
+
+from simcats.ideal_csd import IdealCSDInterface
+from simcats.ideal_csd.geometric import ideal_csd_geometric
+
+__all__ = []
+
+
+class IdealCSDGeometric(IdealCSDInterface):
+    """Geometric simulation approach implementation of the IdealCSDInterface."""
+
+    def __init__(
+        self,
+        tct_params: List[np.ndarray],
+        rotation: float = -np.pi / 4,
+        lut_entries: Union[int, None] = None,
+        cdf_type: str = "sigmoid",
+        cdf_gamma_factor: Union[float, None] = None,
+    ) -> None:
+        """Initializes an object of the class for the geometric simulation approach which is based on total charge
+        transitions (TCTs).
+
+        Args:
+            tct_params (List[np.ndarray]): List containing a numpy array with parameters for every TCT in the CSD.
+                Each array contains all required parameters to describe the TCT form. \n
+                The parameters for a TCT are: \n
+                [0] = length left (in x-/voltage-space, not number of points) \n
+                [1] = length right (in x-/voltage-space, not number of points) \n
+                [2] = gradient left (in voltages) \n
+                [3] = gradient right (in voltages) \n
+                [4] = start position x (bezier curve leftmost point) (in x-/voltage-space, not number of points) \n
+                [5] = start position y (bezier curve leftmost point) (in x-/voltage-space, not number of points) \n
+                [6] = end position x (bezier curve rightmost point) (in x-/voltage-space, not number of points) \n
+                [7] = end position y (bezier curve rightmost point) (in x-/voltage-space, not number of points)
+            rotation (float): Float value defining the rotation to be applied to the TCT (which is usually represented
+                with the tct_params rotated by 45 degrees). Default is -np.pi/4.
+            lut_entries (Union[int, None]): Number of samples for the lookup-table for bezier curves. If this is not None, a
+                lookup-table will be used to evaluate the points on the bezier curves, else they are solved explicitly.
+                Using a lookup-table speeds up the calculation at the possible cost of accuracy. Default is None.
+            cdf_type (str): Name of the type of cumulative distribution function (CDF) to be used. Can be either
+                "cauchy" or "sigmoid". Default is "sigmoid".
+            cdf_gamma_factor (Union[float, None]): The factor used for the calculation of the gamma values of the CDF. If set to None
+                (=default) the default values for the selected cdf_type are used (2.2 for sigmoid, 6.15 for cauchy).
+                Default is None. \n
+                Gamma is calculated as follows: \n
+                gamma = width_bezier_curve / cdf_gamma_factor
+        """
+        self.tct_params = tct_params
+        self.rotation = rotation
+        self.lut_entries = lut_entries
+        self.cdf_type = cdf_type
+        self.cdf_gamma_factor = cdf_gamma_factor
+
+    @property
+    def tct_params(self) -> List[np.ndarray]:
+        """List containing a numpy array with parameters for every TCT in the CSD. Each array contains all required
+        parameters to describe the TCT form.
+        """
+        return self.__tct_params
+
+    @tct_params.setter
+    def tct_params(self, tct_params: list):
+        self.__tct_params = tct_params
+
+    @property
+    def rotation(self) -> float:
+        """Float value defining the rotation to be applied to the TCT (which is usually represented with the tct_params
+        rotated by 45 degrees).
+        """
+        return self.__rotation
+
+    @rotation.setter
+    def rotation(self, rotation: float) -> None:
+        self.__rotation = rotation
+
+    @property
+    def lut_entries(self) -> Union[int, None]:
+        """Number of samples for the lookup-table for bezier curves. If this is not None, a lookup-table will be used to
+        evaluate the points on the bezier curves, else they are solved explicitly.
+        """
+        return self.__lut_entries
+
+    @lut_entries.setter
+    def lut_entries(self, lut_entries: Union[int, None]):
+        self.__lut_entries = lut_entries
+
+    @property
+    def cdf_type(self) -> str:
+        """Name of the type of cumulative distribution function (CDF) to be used."""
+        return self.__cdf_type
+
+    @cdf_type.setter
+    def cdf_type(self, cdf_type: str) -> None:
+        self.__cdf_type = cdf_type
+
+    @property
+    def cdf_gamma_factor(self) -> Union[float, None]:
+        """The factor used for the calculation of the gamma values of the CDF. If set to None (=default) the default values
+        for the selected cdf_type are used (2.2 for sigmoid, 6.15 for cauchy).
+        """
+        return self.__cdf_gamma_factor
+
+    @cdf_gamma_factor.setter
+    def cdf_gamma_factor(self, cdf_gamma_factor: Union[float, None]):
+        self.__cdf_gamma_factor = cdf_gamma_factor
+
+    def get_csd_data(
+        self,
+        volt_limits_g1: np.ndarray,
+        volt_limits_g2: np.ndarray,
+        resolution: Union[int, np.ndarray] = np.array([100, 100]),
+    ) -> Tuple[np.ndarray, np.ndarray]:
+        """Retrieve ideal data (occupation numbers and a lead transition mask) for given gate voltages.
+
+        Args:
+            volt_limits_g1 (np.ndarray): Voltage sweep range of (plunger) gate 1 (second-/x-axis). \n
+                Example: \n
+                [min_V1, max_V1]
+            volt_limits_g2 (np.ndarray): Voltage sweep range of (plunger) gate 2 (first-/y-axis). \n
+                Example: \n
+                [min_V2, max_V2]
+            resolution (np.ndarray): Desired resolution (in pixels) for the gates. If only one value is supplied, a 1D
+                sweep is performed. Then, both gates are swept simultaneously. Default is np.array([100, 100]). \n
+                Example: \n
+                [res_g1, res_g2]
+
+        Returns:
+            Tuple[np.ndarray, np.ndarray]: Occupation numbers and lead transition mask (in our case: total charge
+            transitions). The occupation numbers are stored in a 3-dimensional numpy array. The first two dimensions map
+            to the axis of the CSD, while the third dimension indicates the dot of the corresponding occupation value.
+            The label mask for the lead-to-dot transitions is stored in a 2-dimensional numpy array with the axis
+            mapping to the CSD axis.
+
+        """
+        return ideal_csd_geometric(
+            tct_params=self.__tct_params,
+            volt_limits_g1=volt_limits_g1,
+            volt_limits_g2=volt_limits_g2,
+            resolution=resolution,
+            rotation=self.__rotation,
+            lut_entries=self.__lut_entries,
+            cdf_type=self.__cdf_type,
+            cdf_gamma_factor=self.__cdf_gamma_factor,
+        )
+
+    def __repr__(self):
+        return (
+            self.__class__.__name__
+            + f"(tct_params={self.__tct_params}, rotation={self.__rotation}, lut_entries={self.__lut_entries}, cdf_type='{self.__cdf_type}', cdf_gamma_factor={self.__cdf_gamma_factor})"
+        )

simcats/ideal_csd/geometric/_tct_bezier.py

@@ -84,12 +84,14 @@ def tct_bezier(
 
     # initialize bezier curve
     bezier_curve = bezier.Curve.from_nodes(nodes)
-    xb, yb = sympy.symbols("x y")
-    bezier_implicit = bezier_curve.implicitize()
     # retrieve a lookup-table if the given lut_entries value is not None
     if lut_entries:
         t = np.linspace(0, 1, lut_entries)
         bezier_lut = bezier_curve.evaluate_multi(t)
+    else:
+        xb, yb = sympy.symbols("x y")
+        bezier_implicit = bezier_curve.implicitize()
+        bezier_implicit_solved = sympy.solve(bezier_implicit, yb)
 
     # retrieve length of bezier curve & period length. Both are required to calculate the region
     # where the x-values to be evaluated are located
@@ -116,7 +118,12 @@ def tct_bezier(
         # all other ids are simulated as linear parts
         # lowest value = left bezier anchor
         # highest value = right bezier anchor + #additional_peaks * period length
-        x_range_wave = np.array([tct_params[4], (tct_params[6] + (max_peaks - 1) * (tct_params[0] + tct_params[1]))])
+        x_range_wave = np.array(
+            [
+                tct_params[4],
+                (tct_params[6] + (max_peaks - 1) * (tct_params[0] + tct_params[1])),
+            ]
+        )
         ids_wave = np.where((x_eval + offset_x >= x_range_wave[0]) & (x_eval + offset_x <= x_range_wave[1]))[0]
     else:
         x_range_wave = [x_eval[0], x_eval[-1]]
@@ -138,7 +145,10 @@ def tct_bezier(
                     y_res[x_id] = bezier_lut[1, np.argmin(np.abs(bezier_lut[0, :] - (x_mod_per + offset_x)))]
                 else:
                     # use sympy to solve symbolic expression for x, because s is not linearly mapped to x
-                    temp_y = sympy.solve(bezier_implicit.subs({xb: x_mod_per + offset_x}), yb)
+                    temp_y = [
+                        bezier_implicit_solution.subs({xb: x_mod_per + offset_x})
+                        for bezier_implicit_solution in bezier_implicit_solved
+                    ]
                     # might get two solutions because implicit function might be quadratic. If so, the second solution
                     # is the positive one and selected therefore, as we assume to have only positive y-values after
                     # rotating a signal with only positive x- & y-values by 45 degree
@@ -168,9 +178,10 @@ def tct_bezier(
                     )
                 else:
                     # use sympy to solve symbolic expression for x, because s is not linearly mapped to x
-                    temp_y = sympy.solve(
-                        bezier_implicit.subs({xb: 2 * bezier_length + right_lin_length - x_mod_per + offset_x}), yb
-                    )
+                    temp_y = [
+                        bezier_implicit_solution.subs({xb: 2 * bezier_length + right_lin_length - x_mod_per + offset_x})
+                        for bezier_implicit_solution in bezier_implicit_solved
+                    ]
                     # might get two solutions because implicit function might be quadratic. If so, the second solution
                     # is the positive one and selected therefore, as we assume to have only positive y-values after
                     # rotating a signal with only positive x- & y-values by 45 degree

simcats/support_functions/__init__.py

@@ -3,7 +3,7 @@ SimCATS subpackage with support functions that are not assigned to any specific
 """
 
 from simcats.support_functions._parameter_sampling import ParameterSamplingInterface, NormalSamplingRange, \
-    UniformSamplingRange
+    LogNormalSamplingRange, UniformSamplingRange, ExponentialSamplingRange
 from simcats.support_functions._fermi_filter1d import fermi_filter1d, fermi_dirac_derivative
 from simcats.support_functions._cumulative_distribution_functions import cauchy_cdf, multi_cauchy_cdf, sigmoid_cdf, \
     multi_sigmoid_cdf
@@ -11,6 +11,6 @@ from simcats.support_functions._signed_dist_points_line import signed_dist_point
 from simcats.support_functions._rotate_points import rotate_points
 from simcats.support_functions._plotting import plot_csd
 
-__all__ = ["ParameterSamplingInterface", "NormalSamplingRange", "UniformSamplingRange", "fermi_filter1d",
-           "fermi_dirac_derivative", "cauchy_cdf", "multi_cauchy_cdf", "sigmoid_cdf", "multi_sigmoid_cdf",
-           "signed_dist_points_line", "rotate_points", "plot_csd"]
+__all__ = ["ParameterSamplingInterface", "NormalSamplingRange", "LogNormalSamplingRange", "UniformSamplingRange",
+           "ExponentialSamplingRange", "fermi_filter1d", "fermi_dirac_derivative", "cauchy_cdf", "multi_cauchy_cdf",
+           "sigmoid_cdf", "multi_sigmoid_cdf", "signed_dist_points_line", "rotate_points", "plot_csd"]

simcats/support_functions/_parameter_sampling.py

@@ -2,7 +2,7 @@
 
 The contained functions can be used for example for the parameter sampling in the distortions module.
 
-@author: s.fleitmann
+@author: s.fleitmann, f.fuchs
 """
 
 import warnings
@@ -42,12 +42,14 @@ class ParameterSamplingInterface(ABC):
 
 
 class NormalSamplingRange(ParameterSamplingInterface):
+    """Normal sampling range implementation of ParameterSamplingInterface."""
     def __init__(
         self,
         total_range: Tuple,
         std: float,
+        mean: Union[float, None] = None,
         sampling_range: Union[float, None] = None,
-        rng: np.random.Generator = np.random.default_rng(),
+        rng: Union[np.random.Generator, None] = None,
     ) -> None:
         """This class can be used to generate randomly normal sampled parameters within a given range.
 
@@ -55,22 +57,30 @@ class NormalSamplingRange(ParameterSamplingInterface):
 
         Args:
             total_range (Tuple): The total range in which the parameters can be sampled. This can be narrowed down
-                randomly with the help of sampling_range.
+                randomly with the help of sampling_range. If the normal distribution generates a sample outside this
+                range, a new sample is drawn until a sample inside the sampling_range/total_range was generated,
+                leading to a truncated normal distribution.
             std (float): The standard deviation of the sampled elements, which is used in the normal distribution.
+            mean (Union[float, None]): The mean to be used for the normal distribution. If None, the center of the
+                total range will be used. Defaults to None.
             sampling_range (Union[float, None]): The maximum range in which the parameter is allowed to change during
                 the simulation. The explicit range is set up during the initialization, narrowing down the
                 supplied total_range. Default is None, which leads to no narrowing of the given total_range.
-            rng (np.random.Generator): random number generator used for the sampling of random numbers. Default is the
-                default generator of numpy (np.random.default_rng())
+            rng (np.random.Generator): random number generator used for the sampling of random numbers. If None,  the
+                default generator of numpy (np.random.default_rng()) is used. Default is None.
         """
-        self.__rng = rng
+        if rng:
+            self.__rng = rng
+        else:
+            self.__rng = np.random.default_rng()
         if sampling_range is None:
             self.__range = total_range
         else:
             if np.greater_equal(sampling_range, total_range[1] - total_range[0]):
                 warnings.warn(
                     "The given reduced sampling range is equal or larger than the given total range. As "
-                    "default the given total sampling range is taken."
+                    "default the given total sampling range is taken.",
+                    stacklevel=2,
                 )
                 self.__range = total_range
             else:
@@ -79,11 +89,17 @@ class NormalSamplingRange(ParameterSamplingInterface):
                 )
                 self.__range = (sampled - 0.5 * sampling_range, sampled + 0.5 * sampling_range)
         self.__std = std
+        if mean is not None:
+            self.__mean = mean
+        else:
+            self.__mean = np.mean(self.__range)
         self.__last_sample = None
 
     def sample_parameter(self):
-        sampled = self.__rng.normal(loc=np.mean(self.__range), scale=self.__std)
-        sampled = np.maximum(self.__range[0], np.minimum(self.__range[1], sampled))
+        sampled = self.__rng.normal(loc=self.__mean, scale=self.__std)
+        # repeat sampling until the sampled value is in self.__range
+        while sampled < self.__range[0] or sampled > self.__range[1]:
+            sampled = self.__rng.normal(loc=self.__mean, scale=self.__std)
         self.__last_sample = sampled
         return sampled
 
@@ -93,16 +109,17 @@ class NormalSamplingRange(ParameterSamplingInterface):
     def __repr__(self) -> str:
         return (
             self.__class__.__name__
-            + f"(last_sample={self.last_sample()}, range={self.__range}, std={self.__std}, rng={self.__rng})"
+            + f"(last_sample={self.last_sample()}, range={self.__range}, mean={self.__mean}, std={self.__std}, rng={self.__rng})"
         )
 
 
 class UniformSamplingRange(ParameterSamplingInterface):
+    """Uniform sampling range implementation of ParameterSamplingInterface."""
     def __init__(
         self,
         total_range: Tuple,
         sampling_range: Union[float, None] = None,
-        rng: np.random.Generator = np.random.default_rng(),
+        rng: Union[np.random.Generator, None] = None,
     ) -> None:
         """This class can be used to generate randomly uniform sampled parameters within a given range.
 
@@ -114,17 +131,21 @@ class UniformSamplingRange(ParameterSamplingInterface):
             sampling_range (Union[float, None]): The maximum range in which the parameter is allowed to change during
                 the simulation. The explicit range is set up during the initialization, narrowing down the supplied
                 total_range. Default is None, which leads to no narrowing of the given total_range.
-            rng (np.random.Generator): random number generator used for the sampling of random numbers. Default is the
-                default generator of numpy (np.random.default_rng())
+            rng (np.random.Generator): random number generator used for the sampling of random numbers. If None,  the
+                default generator of numpy (np.random.default_rng()) is used. Default is None.
         """
-        self.__rng = rng
+        if rng:
+            self.__rng = rng
+        else:
+            self.__rng = np.random.default_rng()
         if sampling_range is None:
             self.__range = total_range
         else:
             if np.greater_equal(sampling_range, total_range[1] - total_range[0]):
                 warnings.warn(
                     "The given reduced sampling range is equal or larger than the given total range. As "
-                    "default the given total sampling range is taken."
+                    "default the given total sampling range is taken.",
+                    stacklevel=2,
                 )
                 self.__range = total_range
             else:
@@ -144,3 +165,160 @@ class UniformSamplingRange(ParameterSamplingInterface):
 
     def __repr__(self) -> str:
         return self.__class__.__name__ + f"(last_sample={self.last_sample()}, range={self.__range}, rng={self.__rng})"
+
+
+class LogNormalSamplingRange(ParameterSamplingInterface):
+    """Logarithmic normal sampling range implementation of ParameterSamplingInterface."""
+    def __init__(
+        self,
+        total_range: Tuple,
+        sampling_range: Union[float, None] = None,
+        rng: Union[np.random.Generator, None] = None,
+        mean: float = 0,
+        sigma: float = 1,
+    ) -> None:
+        """This class can be used to generate randomly log-normal sampled parameters within a given range.
+
+        For example, for the distortions used in the simulation of CSDs.
+
+        Args:
+            total_range (Tuple): The total range in which the parameters can be sampled. This can be narrowed down
+                randomly with the help of sampling_range. If the log-normal distribution generates a sample outside this
+                range, a new sample is drawn until a sample inside the sampling_range/total_range was generated, leading
+                toa truncated log-normal distribution.
+            sampling_range (Union[float, None]): The maximum range in which the parameter is allowed to change during
+                the simulation. The explicit range is set up during the initialization, narrowing down the supplied
+                total_range. Default is None, which leads to no narrowing of the given total_range.
+            rng (np.random.Generator): random number generator used for the sampling of random numbers. If None,  the
+                default generator of numpy (np.random.default_rng()) is used. Default is None.
+            mean (float): Mean value of the underlying normal distribution. Default is 0.
+            sigma (float): Standard deviation of the underlying normal distribution. Must be non-negative. Default is 1.
+        """
+        if rng:
+            self.__rng = rng
+        else:
+            self.__rng = np.random.default_rng()
+        self.__mean: float = mean
+        self.__sigma: float = sigma
+        if sampling_range is None:
+            self.__range = total_range
+        else:
+            if np.greater_equal(sampling_range, total_range[1] - total_range[0]):
+                warnings.warn(
+                    "The given reduced sampling range is equal or larger than the given total range. As "
+                    "default the given total sampling range is taken.",
+                    stacklevel=2,
+                )
+                self.__range = total_range
+            else:
+                sampled = self.__rng.uniform(
+                    total_range[0] + 0.5 * sampling_range,
+                    total_range[1] - 0.5 * sampling_range,
+                )
+                self.__range = (
+                    sampled - 0.5 * sampling_range,
+                    sampled + 0.5 * sampling_range,
+                )
+        self.__last_sample = None
+
+    def sample_parameter(self):
+        sampled = self.__rng.lognormal(mean=self.__mean, sigma=self.__sigma)
+        # repeat sampling until the sampled value is in self.__range
+        while sampled < self.__range[0] or sampled > self.__range[1]:
+            sampled = self.__rng.lognormal(mean=self.__mean, sigma=self.__sigma)
+        self.__last_sample = sampled
+        return sampled
+
+    def last_sample(self):
+        return self.__last_sample
+
+    def __repr__(self) -> str:
+        return (
+            self.__class__.__name__
+            + f"(last_sample={self.last_sample()}, range={self.__range}, mean={self.__mean}, sigma={self.__sigma}"
+            + f", rng={self.__rng})"
+        )
+
+
+class ExponentialSamplingRange(ParameterSamplingInterface):
+    """Exponential distribution sampling range implementation of ParameterSamplingInterface."""
+
+    def __init__(
+            self,
+            total_range: Tuple,
+            scale: float,
+            sampling_range: Union[float, None] = None,
+            rng: Union[np.random.Generator, None] = None,
+    ) -> None:
+        """This class can be used to generate randomly sampled parameters from an exponential distribution within a given range.
+
+        The samples are calculated as follows:\n
+        min(sampling_range) + exponential_distribution_sample * (max(sampling_range) - min(Sampling_range))
+
+        To select the correct scale factor (1 / λ), take the following into consideration:\n
+        To have the p percent quantile at position q, the following must be valid:\n
+        q = ln( 1 / (1-p) ) / λ \n
+        with 1 / λ = scale \n
+        So in general the scale is calculated as: \n
+        scale = q / ln( 1 / (1-p) ) \n
+        For example: If it is desired to have 90% of the values in 50% of the sampling range, we get:\n
+        scale = 0.5 / ln( 1 / (1-0.9) ) = 0.21715
+
+        Further reading: https://en.wikipedia.org/wiki/Exponential_distribution#properties
+
+        Used for example for the distortions during the simulation of CSDs.
+
+        Args:
+            total_range (Tuple): The total range in which the parameters can be sampled. This can be narrowed down
+                randomly with the help of the parameter sampling_range. If the exponential distribution generates a
+                sample outside this range, a new sample is drawn until a sample inside the sampling_range/total_range
+                was generated, leading to a truncated exponential distribution.
+            scale (float): The scale of the exponential distribution. See __init__ docstring for more detailed
+                information.
+            sampling_range (Union[float, None]): The maximum range in which the parameter is allowed to change during
+                the simulation. The explicit range is set up during the initialization, narrowing down the
+                supplied total_range. Default is None, which leads to no narrowing of the given total_range.
+            rng (np.random.Generator): random number generator used for the sampling of random numbers. If None, the
+                default generator of numpy (np.random.default_rng()) is used. Default is None.
+        """
+        if rng:
+            self.__rng = rng
+        else:
+            self.__rng = np.random.default_rng()
+        if sampling_range is None:
+            self.__range = total_range
+        else:
+            if np.greater_equal(sampling_range, np.max(total_range) - np.min(total_range)):
+                warnings.warn(
+                    "The given reduced sampling range is equal or larger than the given total range. As "
+                    "default the given total sampling range is taken.",
+                    stacklevel=2,
+                )
+                self.__range = total_range
+            else:
+                sampled = self.__rng.uniform(
+                    np.min(total_range) + 0.5 * sampling_range, np.max(total_range) - 0.5 * sampling_range
+                )
+                if total_range[0] < total_range[1]:
+                    self.__range = (sampled - 0.5 * sampling_range, sampled + 0.5 * sampling_range)
+                else:
+                    self.__range = (sampled + 0.5 * sampling_range, sampled - 0.5 * sampling_range)
+        self.__scale = scale
+        self.__last_sample = None
+
+    def sample_parameter(self):
+        sampled = self.__range[0] + self.__rng.exponential(scale=self.__scale) * (self.__range[1] - self.__range[0])
+        # repeat sampling until the sampled value is in self.__range
+        while sampled < np.min(self.__range) or sampled > np.max(self.__range):
+            sampled = self.__range[0] + self.__rng.exponential(scale=self.__scale) * (self.__range[1] - self.__range[0])
+        self.__last_sample = sampled
+        return sampled
+
+    def last_sample(self):
+        return self.__last_sample
+
+    def __repr__(self) -> str:
+        return (
+                self.__class__.__name__
+                + f"(last_sample={self.last_sample()}, range={self.__range}, scale={self.__scale}, rng={self.__rng})"
+        )

simcats-1.2.0.dist-info/METADATA

@@ -0,0 +1,218 @@
+Metadata-Version: 2.1
+Name: simcats
+Version: 1.2.0
+Summary: SimCATS is a python framework for simulating charge stability diagrams (CSDs) typically measured during the tuning process of qubits.
+Author-email: Fabian Hader <f.hader@fz-juelich.de>, Sarah Fleitmann <s.fleitmann@fz-juelich.de>, Fabian Fuchs <f.fuchs@fz-juelich.de>
+License: CC BY-NC-SA 4.0
+Project-URL: homepage, https://github.com/f-hader/SimCATS
+Project-URL: documentation, https://simcats.readthedocs.io
+Project-URL: source, https://github.com/f-hader/SimCATS
+Project-URL: tracker, https://github.com/f-hader/SimCATS/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering
+Classifier: Typing :: Typed
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bezier
+Requires-Dist: colorednoise
+Requires-Dist: diplib
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: opencv-python
+Requires-Dist: scipy
+Requires-Dist: sympy
+
+<h1 align="center">
+  <img src="https://raw.githubusercontent.com/f-hader/SimCATS/main/SimCATS_symbol.svg" alt="SimCATS logo">
+  <br>
+</h1>
+
+<div align="center">
+  <a href="https://github.com/f-hader/SimCATS/blob/main/LICENSE">
+    <img src="https://img.shields.io/badge/License-CC%20BY--NC--SA%204.0-lightgrey.svg" alt="License: CC BY-NC-SA 4.0"/>
+  </a>
+  <a href="https://pypi.org/project/simcats/">
+    <img src="https://img.shields.io/pypi/v/simcats.svg" alt="PyPi Latest Release"/>
+  </a>
+  <a href="https://simcats.readthedocs.io/en/latest/">
+    <img src="https://img.shields.io/readthedocs/simcats" alt="Read the Docs"/>
+  </a>
+  <a href="https://doi.org/10.1109/TQE.2024.3445967">
+    <img src="https://img.shields.io/badge/DOI-10.1109/TQE.2024.3445967-007ec6.svg" alt="DOI Publication"/>
+  </a>
+</div>
+
+# SimCATS
+
+Simulation of CSDs for Automated Tuning Solutions (`SimCATS`) is a Python framework for simulating charge stability 
+diagrams (CSDs) typically measured during the tuning process of qubits.
+
+## Installation
+
+The framework supports Python versions 3.7 - 3.11 and installs via pip:
+```
+pip install simcats
+```
+
+Alternatively, the `SimCATS` package can be installed by cloning the GitHub repository, navigating to the folder 
+containing the `setup.py` file and executing
+
+```
+pip install .
+```
+
+For the installation in development/editable mode, use the option `-e`.
+
+## Examples / Tutorials
+After installing the package, a good starting point is a look into the Jupyter Notebook 
+`example_SimCATS_simulation_class.ipynb`, which provides an overview of the usage of the simulation class offered by 
+the framework. 
+For more detailed examples and explanations of the geometric ideal CSD simulation using Total Charge Transitions (TCTs), look at the Jupyter Notebook `example_SimCATS_IdealCSDGeometric.ipynb`. This notebook also includes a hint
+regarding the generation of required labels for training algorithms that might need line labels defined as start and
+end points or require semantic information about particular transitions.
+
+## Tests
+
+The tests are written for the `PyTest` framework but should also work with the `unittest` framework.
+
+To run the tests, install the packages `pytest`, `pytest-cov`, and `pytest-xdist` with
+
+```
+pip install pytest pytest-cov pytest-xdist
+```
+
+and run the following command:
+
+```
+pytest --cov=simcats -n auto --dist loadfile .\tests\
+```
+
+The argument 
+- `--cov=simcats` enables a coverage summary of the `SimCATS` package,
+- `-n auto` enables the test to run with multiple threads (auto will choose as many threads as possible, but can be replaced with a specific number of threads to use), and
+- `--dist loadfile` specifies that each file should be executed only by one thread.
+
+<!-- start sec:documentation -->
+## Documentation
+
+The official documentation is hosted on [ReadtheDocs](https://simcats.readthedocs.io), but can also be built locally.
+To do this, first install the packages `sphinx`, `sphinx-rtd-theme`, `sphinx-autoapi`, `myst-nb `, and `jupytext` with
+
+```
+pip install sphinx sphinx-rtd-theme sphinx-autoapi myst-nb jupytext
+```
+
+and then, in the `docs` folder, execute the following command:
+
+```
+.\make html
+```
+
+To view the generated HTML documentation, open the file `docs\build\html\index.html`.
+<!-- end sec:documentation -->
+
+## Structure of SimCATS
+
+The primary user interface for `SimCATS` is the class `Simulation`, which combines all the necessary functionalities to
+measure (simulate) a CSD and adjust the parameters for the simulated measurement. The class `Simulation` and default
+configurations for the simulation (`default_configs`) can be imported directly from `simcats`. Aside from that,
+`SimCATS` contains the subpackages `ideal_csd`, `sensor`, `distortions`, and `support_functions`, described in
+the following sections.
+
+### Module `simulation`
+
+An instance of the simulation class requires
+
+-   an implementation of the `IdealCSDInterface` for the simulation of ideal CSD data,
+-   an implementation of the `SensorInterface` for the simulation of the sensor (dot) reaction based on the ideal CSD
+data, and
+-   (optionally) implementations of the desired types of distortions, which can be implementations from `OccupationDistortionInterface`, `SensorPotentialDistortionInterface`, or `SensorResponseDistortionInterface`.
+
+With an initialized instance of the `Simulation` class, it is possible to run simulations using the `measure` function
+(see `example_SimCATS_simulation_class.ipynb`).
+
+### Subpackage `ideal_csd`
+
+This subpackage contains the `IdealCSDInterface` used by the `Simulation` class  and an implementation of
+the `IdealCSDInterface` (`IdealCSDGeometric`) based on our geometric simulation approach.
+Additionally, it contains in the subpackage `geometric` the functions used by `IdealCSDGeometric`, including the
+implementation of the total charge transition (TCT) definition and functions for calculating the occupations using TCTs.
+
+### Subpackage `distortions`
+
+The distortions subpackage contains the `DistortionInterface` from which the `OccupationDistortionInterface`, the 
+`SensorPotentialDistortionInterface`, and the `SensorResponseDistortionInterface` are derived. Distortion functions used
+in the `Simulation` class have to implement these specific interfaces. Implemented distortions included in the
+subpackage are:
+
+-   white noise, generated by sampling from a normal distribution,
+-   pink noise, generated using the package colorednoise ([https://github.com/felixpatzelt/colorednoise](https://github.com/felixpatzelt/colorednoise)),
+-   random telegraph noise (RTN), generated using the algorithm described in ["Toward Robust Autotuning of Noisy Quantum Dot Devices" by Ziegler et al.](https://doi.org/10.1103/PhysRevApplied.17.024069) (RTN is called sensor jumps there),
+-   dot jumps, simulated using the algorithm described in ["Toward Robust Autotuning of Noisy Quantum Dot Devices" by Ziegler et al.](https://doi.org/10.1103/PhysRevApplied.17.024069) (In the `Simulation` class, this is applied to a whole block of rows or columns, but there is also a function for applying it linewise.), and
+-   lead transition blurring, simulated using Gaussian or Fermi-Dirac blurring.
+
+The implementations also offer the option to set ratios (parameter `ratio`) for the occurrence of the distortion (e.g. dot jumps may only happen sometimes and not in every measurement). Moreover, it is also possible to sample the
+noise parameters from a given sampling range using an object of type `ParameterSamplingInterface`.
+Classes for randomly sampling from a normal distribution or a uniform distribution within a given range are available in
+the subpackage `support_functions`.
+In this case, the strength is randomly chosen from the given range for every measurement.
+Additionally, it is possible to specify that this range should be a smaller subrange of the provided range.
+This allows restricting distortion fluctuations during a simulation while enabling a large variety of different strengths
+for the initialization of the objects. <br>
+RTN, dot jumps, and lead transition blurring are applied in the pixel domain. However, the jump length or the blurring strength should be consistent in the voltage domain even if the resolution changes. Therefore, the parameters
+are given in the voltage domain and adjusted according to the resolution in terms of pixel per voltage. <br>
+For a simulated measurement with a continuous voltage sweep involving an averaging for each pixel, the noise strength of the
+white and pink noise should be adjusted if the resolution (volt per pixel) changes, due to smoothing out the noise. This smoothing depends on the type of averaging used and is not incorporated in the default implementation.
+
+### Subpackage `sensor`
+
+This subpackage contains the `SensorInterface` that defines how a sensor simulation must be implemented to be used by the `Simulation` class. The `SensorPeakInterface` provides the desired representation for the definition of the Coulomb peaks the sensor uses. `SensorGeneric` implements the `SensorInterface` and offers functions for simulating the sensor response and potential. It offers the possibility to simulate with a single peak or multiple sensor peaks. Current implementations of the `SensorPeakInterface` are `SensorPeakGaussian` and `SensorPeakLorentzian`.
+
+### Subpackage `support_functions`
+
+This subpackage contains support functions, which are used by the end user and by different functions of the framework.  
+- `fermi_filter1d` is an implementation of a one-dimensional Fermi-Dirac filter.
+- `plot_csd` plots one and two-dimensional CSDs. The function can also plot ground truth data (see `example_SimCATS_simulation_class.ipynb` for examples).  
+- `rotate_points` simply rotates coordinates (stored in a (n, 2) shaped array) by a given angle. It is especially used during the generation of the ideal data.
+- `ParameterSamplingInterface` defines an interface for randomly sampled (fluctuated) strengths of distortions.
+  - `NormalSamplingRange` and `UniformSamplingRange` are implementations of the `ParameterSamplingInterface`.
+
+## Citations
+
+```bibtex
+@article{hader2024simcats,
+  author={Hader, Fabian and Fleitmann, Sarah and Vogelbruch, Jan and Geck, Lotte and Waasen, Stefan van},
+  journal={IEEE Transactions on Quantum Engineering}, 
+  title={Simulation of Charge Stability Diagrams for Automated Tuning Solutions (SimCATS)}, 
+  year={2024},
+  volume={5},
+  pages={1-14},
+  doi={10.1109/TQE.2024.3445967}
+}
+```
+
+## License, CLA, and Copyright
+
+[![CC BY-NC-SA 4.0][cc-by-nc-sa-shield]][cc-by-nc-sa]
+
+This work is licensed under a
+[Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License][cc-by-nc-sa].
+
+[![CC BY-NC-SA 4.0][cc-by-nc-sa-image]][cc-by-nc-sa]
+
+[cc-by-nc-sa]: http://creativecommons.org/licenses/by-nc-sa/4.0/
+[cc-by-nc-sa-image]: https://licensebuttons.net/l/by-nc-sa/4.0/88x31.png
+[cc-by-nc-sa-shield]: https://img.shields.io/badge/License-CC%20BY--NC--SA%204.0-lightgrey.svg
+
+Contributions must follow the Contributor License Agreement. For more information, see the CONTRIBUTING.md file at the top of the GitHub repository.
+
+Copyright © 2024 Forschungszentrum Jülich GmbH - Central Institute of Engineering, Electronics and Analytics (ZEA) - Electronic Systems (ZEA-2)

{simcats-1.0.0.dist-info → simcats-1.2.0.dist-info}/RECORD

@@ -1,36 +1,37 @@
-simcats/__init__.py,sha256=h98g7mCms0R2D4fupAVJ6N3jYksIUQs3jnQiqxBE1lo,300
+simcats/__init__.py,sha256=pnTS1t8IQKm2SpadtblS8VKUFKm0OfBkiT7rQGzj8Ws,300
 simcats/_default_configs.py,sha256=wHWa4wyTVtZf9J37WdcMlvM7XeI_OZhl8NB7lrBi-yI,6980
 simcats/_simulation.py,sha256=xvKLnOzwc8uGGLfXvBZPaLYYPHBaXcwwtlYmJ3zTkUU,24795
 simcats/distortions/__init__.py,sha256=3oXqKm1rkznDKhWeitZxYJyb1wFMdan6CBfBw673J7A,1368
 simcats/distortions/_distortion_interfaces.py,sha256=8twWE8FX8fqiLlxrcSOBaMZCc3boDbE6n_b4587-ra4,6717
-simcats/distortions/_dot_jumps.py,sha256=ER-HOVRHLS7Uvivm9YYxNNmm9-mcsugDc_oOUftddyk,37971
+simcats/distortions/_dot_jumps.py,sha256=6segzH8VWaUlRPMcWjkDacwyCcN8bPhfWyrYQD8UaoA,38162
 simcats/distortions/_pink_noise.py,sha256=2-ZvNAvtsypNHqLXN_FfGR-iWnAGgXWZxTS7LKk73pQ,5233
 simcats/distortions/_random_telegraph_noise.py,sha256=psRV-tosDXHC0xBSZyrKZAgRBMQoxSeeDTRIpUsJ9hg,16785
 simcats/distortions/_transition_blurring.py,sha256=3kryfx3VEnJpAgPfoJF-Z4leoSFrzGUwf-5mb8bXD3o,13631
 simcats/distortions/_white_noise.py,sha256=toxal_V2aPxxqoxpsJz3-lH7rtNjzsz5aoTbgNhiWxU,4413
-simcats/ideal_csd/__init__.py,sha256=cC6IQre0RyoqH0yZ6AxvOKPQCcdb2D_gb0hMQBYYl6o,310
+simcats/ideal_csd/__init__.py,sha256=jxQkBf_z1xIclUcqeur6OVzrFJhd9eAXFF9PJdb091I,316
 simcats/ideal_csd/_ideal_csd_interface.py,sha256=3PjLgv_MjIlN2YqbpLwrJysukntftZSBCrBBPwe0HSA,2334
 simcats/ideal_csd/geometric/__init__.py,sha256=uXqR4qGbBcTQ8WdIO56ZxHWXqbn85yvuVlm5zJV7iVc,927
 simcats/ideal_csd/geometric/_calculate_all_bezier_anchors.py,sha256=AvSsOsiu5H3HKoJwwZ1797T3yHoRc6Rj2YT-JJujaIY,6491
 simcats/ideal_csd/geometric/_generate_lead_transition_mask.py,sha256=QOYSNSy5IHiNefmC37KsuM3484xJfsl8yNeo4o5Xdws,6316
 simcats/ideal_csd/geometric/_get_electron_occupation.py,sha256=rEW9guTxM4pTGy9vtQ34NP4zxRaMNk-LQstfCkq4OEw,13461
-simcats/ideal_csd/geometric/_ideal_csd_geometric.py,sha256=xgQG668sJAFPM9VDUULPhgqpK4XpY-m09Rt27WJBgEE,17180
+simcats/ideal_csd/geometric/_ideal_csd_geometric.py,sha256=gpYVgRx_rRB46FyaKntg9CWIpGSP4uroJGeyeufmoKE,10077
+simcats/ideal_csd/geometric/_ideal_csd_geometric_class.py,sha256=Qx1IQy4NX4gtkFQGBaQRxjW46urv95mMQI_enWRUl4M,7481
 simcats/ideal_csd/geometric/_initialize_tct_functions.py,sha256=z1rCkKLM68e97xQkdwnUq5DGuCkHiOADRfwiDb2I3kE,3161
-simcats/ideal_csd/geometric/_tct_bezier.py,sha256=R7MiaUHosB0CJjGtPnz6GO50rj6lcYpVD2-_RExCDj0,11711
+simcats/ideal_csd/geometric/_tct_bezier.py,sha256=xDBlEylwYvnX-xOdUt-N7P7k9i0yzTce9b3dXZa_Zx4,12067
 simcats/sensor/__init__.py,sha256=v9aG6_WGYF5Dq_OFHHn2NQxZx2X2HGg0nkglz5wSoHw,611
 simcats/sensor/_gaussian_sensor_peak.py,sha256=7xrSfl505MygBJ7Nu3V3RJpNq8q-mjukVDcrL-ezEuA,4039
 simcats/sensor/_generic_sensor.py,sha256=88E6xP3r5GZCBKaR7TKtqrWovR4XW-mm6YUwL96L_AQ,10441
 simcats/sensor/_lorentzian_sensor_peak.py,sha256=Rj3Tpk6dksZGfOAHhdSGQR-wJo3ehdmXnumXyGuaNC4,3952
 simcats/sensor/_sensor_interface.py,sha256=mn5L9WbAIMun_ou0AHgOV6XiBeykYPugndLAeufadTo,5064
-simcats/support_functions/__init__.py,sha256=xkd9-ko2AW26m0_Ae4O4irdclym6fY0qP9Ku3-RZrVo,982
+simcats/support_functions/__init__.py,sha256=6aXPXtvcaL4bcOADy1yWhhyehT6BDs3Yt_3uOFbBE50,1086
 simcats/support_functions/_cumulative_distribution_functions.py,sha256=pE01RoSL2VwtkBP7xYivd-vcd6krSJrb4xb8MCfyRBA,3366
 simcats/support_functions/_fermi_filter1d.py,sha256=F4GrdLt0bOXidRdg0P-163Op-bxKvgHte3ENI39qYAk,3706
-simcats/support_functions/_parameter_sampling.py,sha256=APtgokKp-WIFKBrJeZy7fLJ-OiUkhXIeXTn9kPEVyYE,6157
+simcats/support_functions/_parameter_sampling.py,sha256=xEd4V0bUqpkE5DpZA0i1YNe8G86IZP1LB2dmkFTg3l0,15331
 simcats/support_functions/_plotting.py,sha256=xc050m4W6RZm8XdOdqruc-6IYyhzW9UFvNlJEgkJRi8,9070
 simcats/support_functions/_rotate_points.py,sha256=4tgzE4a4uykBVw2pSK55DzGe-5n9N38nsBYhfA38Qgs,778
 simcats/support_functions/_signed_dist_points_line.py,sha256=dMnDoBARY7C48xCHFp8mNFNCkPk7YUiaWaRqAsindsE,908
-simcats-1.0.0.dist-info/LICENSE,sha256=aZs_e2FTt6geKaC1hd9FpoxERpb5YHhxJ608urp4nig,21294
-simcats-1.0.0.dist-info/METADATA,sha256=VflEB_fpiX0r0eC1OrCMEluhFI1s_j_1ONKvU5_sW44,10999
-simcats-1.0.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-simcats-1.0.0.dist-info/top_level.txt,sha256=M-ExkkJ_NLsuuJiDo3iM2qPPPsEX29E2MQUmegBZ8Wk,8
-simcats-1.0.0.dist-info/RECORD,,
+simcats-1.2.0.dist-info/LICENSE,sha256=aZs_e2FTt6geKaC1hd9FpoxERpb5YHhxJ608urp4nig,21294
+simcats-1.2.0.dist-info/METADATA,sha256=QFMyj-AF9-K0_0u5mnPbCO1AXlB7l0gJqTDuIdT3ixg,11918
+simcats-1.2.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+simcats-1.2.0.dist-info/top_level.txt,sha256=M-ExkkJ_NLsuuJiDo3iM2qPPPsEX29E2MQUmegBZ8Wk,8
+simcats-1.2.0.dist-info/RECORD,,

{simcats-1.0.0.dist-info → simcats-1.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: setuptools (75.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

simcats-1.0.0.dist-info/METADATA

@@ -1,187 +0,0 @@
-Metadata-Version: 2.1
-Name: simcats
-Version: 1.0.0
-Summary: SimCATS is a python framework for simulating charge stability diagrams (CSDs) typically measured during the tuning process of qubits.
-Author-email: Fabian Hader <f.hader@fz-juelich.de>, Sarah Fleitmann <s.fleitmann@fz-juelich.de>, Fabian Fuchs <f.fuchs@fz-juelich.de>
-License: CC BY-NC-SA 4.0
-Project-URL: homepage, https://github.com/f-hader/SimCATS
-Project-URL: documentation, https://simcats.readthedocs.io
-Project-URL: source, https://github.com/f-hader/SimCATS
-Project-URL: tracker, https://github.com/f-hader/SimCATS/issues
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Science/Research
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Topic :: Scientific/Engineering
-Classifier: Typing :: Typed
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: bezier
-Requires-Dist: colorednoise
-Requires-Dist: diplib
-Requires-Dist: matplotlib
-Requires-Dist: numpy
-Requires-Dist: opencv-python
-Requires-Dist: scipy
-Requires-Dist: sympy
-
-# SimCATS
-
-Simulation of CSDs for Automated Tuning Solutions (`SimCATS`) is a python framework for simulating charge stability 
-diagrams (CSDs) typically measured during the tuning process of qubits.
-
-## Installation
-
-The framework supports python versions 3.7 - 3.11 and can be installed with pip:
-```
-pip install simcats
-```
-
-Alternatively, the `SimCATS` package can be installed by cloning the GitHub repository, navigating to the folder 
-containing the `setup.py` file and executing
-
-```
-pip install .
-```
-
-For installation in development/editable mode use the option `-e`.
-
-## Examples / Tutorials
-After the package is installed, a good starting point is a look into the Jupyter Notebook 
-`example_SimCATS_simulation_class.ipynb`, which provides an overview for the usage of the simulation class offered by 
-the framework. 
-For more detailed examples and explanations of the geometric ideal CSD simulation using Total Charge Transitions (TCTs),
-have a look at the Jupyter Notebook `example_SimCATS_IdealCSDGeometric.ipynb`. This notebook also includes a hint
-regarding the generation of required labels for training algorithms, that might need line labels defined as start and
-end points or require semantic information about particular transitions.
-
-## Tests
-
-The test are written for the `PyTest` framework but should also work with the `unittest` framework.
-
-To run the tests install the packages `pytest`, `pytest-cov` and `pytest-xdist` with
-
-```
-pip install pytest pytest-cov pytest-xdist
-```
-
-and then simply run following command in the terminal of your choice:
-
-```
-pytest --cov=simcats -n auto --dist loadfile .\tests\
-```
-
-The argument `--cov=simcats` enables a coverage summary of the `SimCATS` package, the argument `-n auto` enables the
-test to run with multiple threads (auto will choose as many threads as possible, but can be replaced with a specific
-number of threads to use) and the argument `--dist loadfile` specifies that each file should be executed only by one
-thread.
-
-<!-- start sec:documentation -->
-## Documentation
-
-The official documentation is hosted on [ReadtheDocs](https://simcats.readthedocs.io), but can also be build locally.
-To do this, first install the packages `sphinx`, `sphinx-rtd-theme`, `sphinx-autoapi`,`myst-nb ` and `jupytext` with
-
-```
-pip install sphinx sphinx-rtd-theme sphinx-autoapi myst-nb jupytext
-```
-
-and then, in the `docs` folder, execute the following command in a terminal of your choice:
-
-```
-.\make html
-```
-
-To view the generated HTML documentation open the file `docs\build\html\index.html` with a browser of your choice.
-<!-- end sec:documentation -->
-
-## Structure of SimCATS
-
-The main user interface for `SimCATS` is the class `Simulation`, which combines all the necessary functionalities to
-measure (simulate) a CSD and to adjust the parameters for the simulated measurement. The class `Simulation` and default
-configurations for the simulation (`default_configs`) can be imported directly from `simcats`. Asides from that,
-`SimCATS` contains the subpackages `ideal_csd`, `sensor`, `distortions`, and `support_functions`. These are described in
-the following sections.
-
-### Module `simulation`
-
-An instance of the simulation class requires
-
--   an implementation of the `IdealCSDInterface` for the simulation of ideal CSD data,
--   an implementation of the `SensorInterface` for the simulation of the sensor (dot) reaction based on the ideal CSD
-data, and
--   (optionally) implementations of the desired types of distortions, which can be implementations from either
-`OccupationDistortionInterface`, `SensorPotentialDistortionInterface`, or `SensorResponseDistortionInterface`.
-
-With an initialized instance of the `Simulation` class it is possible to run simulations using the `measure` function
-(see `example_SimCATS_simulation_class.ipynb`).
-
-### Subpackage `ideal_csd`
-
-This subpackage contains the `IdealCSDInterface`, that is used by the `Simulation` class for the generation of ideal CSD
-data, and an implementation of the `IdealCSDInterface` (`IdealCSDGeometric`) based on our geometric simulation approach.
-Additionally, in the subpackage `geometric`, it contains the functions used by `IdealCSDGeometric`, including the
-implementation of the total charge transition (TCT) definition and functions for calculating the occupations using TCTs.
-
-### Subpackage `distortions`
-
-The distortions subpackage contains the `DistortionInterface` from which the `OccupationDistortionInterface`, the 
-`SensorPotentialDistortionInterface`, and the `SensorResponseDistortionInterface` are derived. Distortion functions used
-in the `Simulation` class have to implement these specific interfaces. Implemented distortions included in the
-subpackage are:
-
--   white noise, generated by sampling from a normal distribution,
--   pink noise, generated using the package colorednoise ([https://github.com/felixpatzelt/colorednoise](https://github.com/felixpatzelt/colorednoise)),
--   random telegraph noise (RTN), generated using the algorithm described in ["Toward Robust Autotuning of Noisy Quantum Dot Devices" by Ziegler et al.](https://doi.org/10.1103/PhysRevApplied.17.024069) (RTN is called sensor jumps there),
--   dot jumps, simulated using the algorithm described in ["Toward Robust Autotuning of Noisy Quantum Dot Devices" by Ziegler et al.](https://doi.org/10.1103/PhysRevApplied.17.024069) (In the `Simulation` class this is applied to a whole block of rows or columns, but there is also a function for applying it linewise.), and
--   lead transition blurring, simulated using gaussian blurring.
-
-The implementations also offer the option to set ratios (parameter `ratio`), for how often the distortion is active
-(f.e. dot jumps may only happen sometimes and not in every measurement). Moreover, it is also possible to sample the
-noise parameters from a given sampling range. This can be done by using an object of type `ParameterSamplingInterface`.
-Classes for randomly sampling from a normal distribution or a uniform distribution within a given range are available in
-the subpackage `support_functions`.
-In this case the strength is randomly chosen from the given range for every measurement.
-Additionally, it is possible to specify, that this range should be a smaller subrange of the provided range.
-This allows to restrict distortion fluctuations during a simulation while allowing a large variety of different strengths
-for the initialization of the objects. <br>
-RTN, dot jumps and lead transition blurring are applied in the pixel domain. However, the length of jumps or the strength
-of the blurring should be consistent in the voltage domain even if the resolution changes. Therefore, the parameters
-are given in the voltage domain and adjusted according to the resolution in terms of pixel per voltage. <br>
-If a measurement with a continuous voltage sweep and averaging for each pixel is simulated, the noise strength of the white and pink noise should be adjusted if the resolution (volt per pixel) changes, as some of the noise is smoothed out. This smoothing depends on the type of averaging that is used and is not incorporated in the default implementation.
-
-### Subpackage `sensor`
-
-This subpackage contains the `SensorInterface` that defines how a sensor simulation must be implemented to be used by the `Simulation` class. The `SensorPeakInterface` provides the desired representation for the definition of the Coulomb peaks used by the sensor. `SensorGeneric` implements the `SensorInterface` and offers functions for simulating the sensor response and the sensor potential. It offers the possibility to simulate with a single or multiple sensor peaks. Current implementations of the `SensorPeakInterface` are `SensorPeakGaussian` and `SensorPeakLorentzian`.
-
-### Subpackage `support_functions`
-
-This subpackage contains support functions, which are used by the end user as well as from different functions of the framework.  
-- `fermi_filter1d` is an implementation of a one dimensional Fermi-Dirac filter.
-- `plot_csd` is a function for plotting one and two-dimensional CSDs. The function can also be used to plot ground truth data (see `example_SimCATS_simulation_class.ipynb` for examples).  
-- `rotate_points` is a function for simply rotating coordinates (stored in a (n, 2) shaped array) by a given angle. This is especially used during the generation of the ideal data.
-- `ParameterSamplingInterface` defines an interface that can be implemented for randomly sampling (fluctuating) strengths of distortions.
-  - `NormalSamplingRange` and `UniformSamplingRange` are implementations of the `ParameterSamplingInterface`.
-
-## License, CLA, and Copyright
-
-[![CC BY-NC-SA 4.0][cc-by-nc-sa-shield]][cc-by-nc-sa]
-
-This work is licensed under a
-[Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License][cc-by-nc-sa].
-
-[![CC BY-NC-SA 4.0][cc-by-nc-sa-image]][cc-by-nc-sa]
-
-[cc-by-nc-sa]: http://creativecommons.org/licenses/by-nc-sa/4.0/
-[cc-by-nc-sa-image]: https://licensebuttons.net/l/by-nc-sa/4.0/88x31.png
-[cc-by-nc-sa-shield]: https://img.shields.io/badge/License-CC%20BY--NC--SA%204.0-lightgrey.svg
-
-Contributions must follow the Contributor License Agreement. For more information see the CONTRIBUTING.md file at the top level of the GitHub repository.
-
-Copyright © 2023 Forschungszentrum Jülich GmbH - Central Institute of Engineering, Electronics and Analytics (ZEA) - Electronic Systems (ZEA-2)