simcats 1.1.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

simcats/support_functions/_parameter_sampling.py

@@ -7,12 +7,10 @@ The contained functions can be used for example for the parameter sampling in th
 
 import warnings
 from abc import ABC, abstractmethod
-from typing import Tuple, Union
+from typing import Tuple, Optional
 
 import numpy as np
 
-__all__ = []
-
 
 class ParameterSamplingInterface(ABC):
     """Interface for parameter sampling.
@@ -47,8 +45,9 @@ class NormalSamplingRange(ParameterSamplingInterface):
         self,
         total_range: Tuple,
         std: float,
-        sampling_range: Union[float, None] = None,
-        rng: Union[np.random.Generator, None] = None,
+        mean: Optional[float] = None,
+        sampling_range: Optional[float] = None,
+        rng: Optional[np.random.Generator] = None,
     ) -> None:
         """This class can be used to generate randomly normal sampled parameters within a given range.
 
@@ -60,7 +59,9 @@ class NormalSamplingRange(ParameterSamplingInterface):
                 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.
-            sampling_range (Union[float, None]): The maximum range in which the parameter is allowed to change during
+            mean (Optional[float]): 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 (Optional[float]): 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
@@ -86,13 +87,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 = 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=np.mean(self.__range), scale=self.__std)
+            sampled = self.__rng.normal(loc=self.__mean, scale=self.__std)
         self.__last_sample = sampled
         return sampled
 
@@ -102,7 +107,7 @@ 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})"
         )
 
 
@@ -111,8 +116,8 @@ class UniformSamplingRange(ParameterSamplingInterface):
     def __init__(
         self,
         total_range: Tuple,
-        sampling_range: Union[float, None] = None,
-        rng: Union[np.random.Generator, None] = None,
+        sampling_range: Optional[float] = None,
+        rng: Optional[np.random.Generator] = None,
     ) -> None:
         """This class can be used to generate randomly uniform sampled parameters within a given range.
 
@@ -121,11 +126,11 @@ class UniformSamplingRange(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.
-            sampling_range (Union[float, None]): The maximum range in which the parameter is allowed to change during
+            sampling_range (Optional[float]): 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.
+            rng (Optional[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
@@ -165,8 +170,8 @@ class LogNormalSamplingRange(ParameterSamplingInterface):
     def __init__(
         self,
         total_range: Tuple,
-        sampling_range: Union[float, None] = None,
-        rng: Union[np.random.Generator, None] = None,
+        sampling_range: Optional[float] = None,
+        rng: Optional[np.random.Generator] = None,
         mean: float = 0,
         sigma: float = 1,
     ) -> None:
@@ -179,11 +184,11 @@ class LogNormalSamplingRange(ParameterSamplingInterface):
                 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
+            sampling_range (Optional[float]): 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.
+            rng (Optional[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.
         """
@@ -231,3 +236,87 @@ class LogNormalSamplingRange(ParameterSamplingInterface):
             + 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: Optional[float] = None,
+            rng: Optional[np.random.Generator] = 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 (Optional[float]): 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 (Optional[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/support_functions/_pixel_volt_transformation.py

@@ -0,0 +1,24 @@
+"""This module contains functions for transforming pixel coordinates into voltages
+
+@author: b.papajewski
+"""
+
+import numpy as np
+
+
+def pixel_to_volt_1d(pixel: int, pixel_num: int, volt_limits: np.ndarray) -> np.ndarray:
+    """Method that maps a pixel index to a voltage value within specified voltage limits.
+
+    This function linearly maps a pixel position within a span of `pixel_num` pixels to a corresponding voltage value.
+    The voltage values of the pixel span change uniformly between the two values in `volt_limits`.
+
+    Args:
+        pixel (int): The pixel index starting at 0.
+        pixel_num (int): Total number of pixels in the span.
+        volt_limits (np.ndarray): A 1D array of shape (2,) containing the start and end voltage values. The start value
+            is the first of the two values and the end value is the last one.
+
+    Returns:
+        np.ndarray: The voltage value corresponding to the given pixel index.
+    """
+    return volt_limits[0] + (volt_limits[1] - volt_limits[0]) * (pixel / pixel_num)

simcats/support_functions/_reset_offset_mu_sens.py

@@ -0,0 +1,43 @@
+"""This module contains functions for resetting the sensor to a fixed position.
+
+@author: f.hader
+"""
+
+import numpy as np
+
+__all__ = []
+
+
+def reset_offset_mu_sens(dqd_sim: "Simulation",
+                         target_mu_sens: float,
+                         sweep_range_g1: np.ndarray,
+                         sweep_range_g2: np.ndarray, ):
+    """
+    Helper function to reset the sensor offset mu sens before measuring a CSD.
+
+    Can be used to reset the sensor to the steepest point before each CSD measurement. For example, this applies to
+    configs generated by sample_random_variations_v3_config with the set_sensor_potential_offset_to_steepest_point
+    option, which creates a configuration where the offset corresponds to the steepest point when no voltages are
+    applied.
+
+    **Warning**: This alters the provided Simulation object! Make sure to store the previous sensor offset if you want
+    to re-use it later to reset the sensor to this point again.
+
+    Args:
+        dqd_sim (Simulation): SimCATS Simulation object, of which the offset_mu_sens should be adjusted, so that the
+            sensor has the specified target_mu_sens at the initial sweep voltages.
+        target_mu_sens: The target mu sens to be reached at the initial sweep voltages.
+        sweep_range_g1 (np.ndarray): Voltage sweep range of (plunger) gate 1 (second-/x-axis). \n
+            Example: \n
+            [min_V1, max_V1]
+        sweep_range_g2 (np.ndarray): Voltage sweep range of (plunger) gate 2 (first-/y-axis). \n
+            Example: \n
+            [min_V2, max_V2]
+    """
+    # calculate potential to reset offset_mu_sens
+    occupations, _ = dqd_sim.ideal_csd_config.get_csd_data(volt_limits_g1=sweep_range_g1,
+                                                           volt_limits_g2=sweep_range_g2,
+                                                           resolution=2)
+    potentials = dqd_sim.sensor.sensor_potential(occupations, sweep_range_g1, sweep_range_g2)
+    # the new offset is calculated as follows: target_offset - (potentials[0] - current_offset)
+    dqd_sim.sensor.offset_mu_sens = target_mu_sens - (potentials[0] - dqd_sim.sensor.offset_mu_sens)

{simcats-1.1.0.dist-info → simcats-2.0.0.dist-info}/METADATA

@@ -1,9 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: simcats
-Version: 1.1.0
+Version: 2.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
+Author-email: Fabian Hader <f.hader@fz-juelich.de>, Sarah Fleitmann <s.fleitmann@fz-juelich.de>, Benjamin Papajewski <b.papajewski@fz-juelich.de>, Fabian Fuchs <f.fuchs@fz-juelich.de>, Karin Havemann <k.havemann@fz-juelich.de>, Jan Vogelbruch <j.vogelbruch@fz-juelich.de>
+License-Expression: 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
@@ -30,11 +30,37 @@ Requires-Dist: numpy
 Requires-Dist: opencv-python
 Requires-Dist: scipy
 Requires-Dist: sympy
+Dynamic: license-file
+
+<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 (Paper)-10.1109/TQE.2024.3445967-007ec6.svg" alt="DOI Paper"/>
+  </a>
+  <a href="https://doi.org/10.5281/zenodo.13805205">
+    <img src="https://img.shields.io/badge/DOI (Code)-10.5281/zenodo.13805205-007ec6.svg" alt="DOI Code"/>
+  </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.
+diagrams (CSDs) typically measured during the tuning process of qubits. <br>
+Starting with version 2.0, the framework additionally allows simulating sensor scans. This enables to simulate the
+(re)configuration of the sensor dot before measuring a CSD. 
 
 ## Installation
 
@@ -56,9 +82,10 @@ For the installation in development/editable mode, use the option `-e`.
 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.
+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
 
@@ -78,7 +105,8 @@ 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
+- `-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 -->
@@ -105,8 +133,8 @@ To view the generated HTML documentation, open the file `docs\build\html\index.h
 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.
+`SimCATS` contains the subpackages `ideal_csd`, `sensor`, `distortions`, and `support_functions`, described in the
+following sections.
 
 ### Module `simulation`
 
@@ -115,21 +143,24 @@ 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`.
+-   (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.
+This subpackage contains the `IdealCSDInterface` used by the `Simulation` class and an implementation of the
+`IdealCSDInterface` (`IdealCSDGeometric`) based on our geometric simulation approach. Please have a look at the notebook
+`example_SimCATS_IdealCSDGeometric.ipynb` and the `SimCATS` paper for detailed explanations regarding the geometric
+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 
+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:
@@ -140,22 +171,41 @@ subpackage are:
 -   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.
+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`.
+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`. <br>
+Starting with version 2.0, an extension of the `SensorInterface` called `SensorScanSensorInterface` is available.
+Implementations of this interface allow simulating sensor scans in addition to CSDs. This enables to simulate the
+(re)configuration of the sensor dot before measuring a CSD. `SensorScanSensorGeneric` implements the
+`SensorScanSensorInterface`, modeling the sensor dot as three resistors in series (barrier, dot, barrier). The function
+describing the dot is similar to the function in the `SensorGeneric`, but has an additional final rise of the signal
+after the last Coulomb peak (an implementation of the `SensorRiseInterface`). A new interface called 
+`BarrierFunctionInterface` defines how the barrier functions must be implemented. These functions, which basically model 
+the shape of a pinch-off measurement, are currently implemented using generalized logistic functions 
+(`BarrierFunctionGLF`, `BarrierFunctionMultiGLF`). The potentials for both barriers and the dot itself are calculated 
+from the applied voltages and provided lever-arms. Then, the barrier and dot functions are applied to calculate the 
+individual conductances. Finally, these conductances are combined to retrieve the sensor signal (proportional to the 
+total conductance across the sensor dot). 
+
 
 ### Subpackage `support_functions`
 
@@ -166,6 +216,20 @@ This subpackage contains support functions, which are used by the end user and b
 - `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]
@@ -181,4 +245,4 @@ This work is licensed under a
 
 Contributions must follow the Contributor License Agreement. For more information, see the CONTRIBUTING.md file at the top of the GitHub repository.
 
-Copyright © 2023 Forschungszentrum Jülich GmbH - Central Institute of Engineering, Electronics and Analytics (ZEA) - Electronic Systems (ZEA-2)
+Copyright © 2026 Peter Grünberg Institute - Integrated Computing Architectures (ICA / PGI-4), Forschungszentrum Jülich GmbH

simcats-2.0.0.dist-info/RECORD

@@ -0,0 +1,53 @@
+simcats/__init__.py,sha256=BCQvUsAPnS3939FRFakyDF1xwem2JXaWr2qxOrUDr70,316
+simcats/_default_configs.py,sha256=_Q8LWGeplNaKRTexNrN4rOVQAOrF-rFMvWtci1-0w18,16061
+simcats/_simulation.py,sha256=2Ti-aZpD9rqKe_iDTgKn-ttH3tqEbzXbxtPWm8gepjY,45747
+simcats/config_samplers/_GaAs_v1_random_variations_v3_config_sampler.py,sha256=dKswkcEFWGPFDlh2uUtA2psiugZHQFJbcc6dN7bWqrI,53839
+simcats/config_samplers/__init__.py,sha256=2zcXSBoP7FZP88INUQluBPqZr1_RwE5U0B71rrUE_ew,281
+simcats/distortions/__init__.py,sha256=3oXqKm1rkznDKhWeitZxYJyb1wFMdan6CBfBw673J7A,1368
+simcats/distortions/_distortion_interfaces.py,sha256=fHQsgyFNfLdKwWj24_5DvF5GwLFZIDeLwQ424s-P6J0,6714
+simcats/distortions/_dot_jumps.py,sha256=-fCC_FOYFhqFQQYSIcvrjd9H0cQHiOfR87YhENbSTPQ,38469
+simcats/distortions/_pink_noise.py,sha256=2-ZvNAvtsypNHqLXN_FfGR-iWnAGgXWZxTS7LKk73pQ,5233
+simcats/distortions/_random_telegraph_noise.py,sha256=sY8iK_3LElICujBa98xZjoi-to_Z0pySCCibLQ8q5mQ,16844
+simcats/distortions/_transition_blurring.py,sha256=RsBA_wZkL1_vux8wu2aNI0s7uI36Z3szCIOa6P_gIw4,13629
+simcats/distortions/_white_noise.py,sha256=4yr5UhQ1sQftj1jVspGsUaSoYob334DBKoQeB3k63oE,4420
+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=Q5lqfn8OuBW6HjYCWmJIb0dyvISz6ftnDrQIRFuiT3I,6313
+simcats/ideal_csd/geometric/_get_electron_occupation.py,sha256=A3srfb700sX8v0SRG4rhVMA7XxvyottO5_8fR7VlzrY,13452
+simcats/ideal_csd/geometric/_ideal_csd_geometric.py,sha256=nPrIFMuO3YD38jWn8yXw0b6exWAv8OWcO6aPryprrLQ,10075
+simcats/ideal_csd/geometric/_ideal_csd_geometric_class.py,sha256=xMzzVW85NoqOnAM30Er0YlsWvB8l1a1lqAMYLCdItrA,7467
+simcats/ideal_csd/geometric/_initialize_tct_functions.py,sha256=z1rCkKLM68e97xQkdwnUq5DGuCkHiOADRfwiDb2I3kE,3161
+simcats/ideal_csd/geometric/_tct_bezier.py,sha256=3eUn6LFVOYXXI6-srV0MPUDMK2fddq1afUY6FDSGmCk,12065
+simcats/sensor/__init__.py,sha256=KAn5mv7AJI-Np8no9FHdYOvQUCRGUB1M6FLNuMvvml8,913
+simcats/sensor/_sensor_generic.py,sha256=HIzIcWw8AvFBKAvDNNssluWEOySx9GvrtmopsaC4bjA,10453
+simcats/sensor/_sensor_interface.py,sha256=URtfjqhVCKw-VCKi4sE1Hb-9Xj-RqORJCqJOekwCcgg,15009
+simcats/sensor/_sensor_peak_gaussian.py,sha256=7xrSfl505MygBJ7Nu3V3RJpNq8q-mjukVDcrL-ezEuA,4039
+simcats/sensor/_sensor_peak_lorentzian.py,sha256=Rj3Tpk6dksZGfOAHhdSGQR-wJo3ehdmXnumXyGuaNC4,3952
+simcats/sensor/_sensor_rise_glf.py,sha256=CXXLNijyID1k2p3YgLJRm7YT5ehmYGtf15Ru7wX4XUE,11470
+simcats/sensor/_sensor_scan_sensor_generic.py,sha256=DLxZ29WVH4f441T72qe5Tx34fkO8e5qnKowBMvJwlqE,55927
+simcats/sensor/barrier_function/__init__.py,sha256=BI5RFhG3gYwT2h77TMkjwhBlc4MMk-xWmed0Jt5d0zg,487
+simcats/sensor/barrier_function/_barrier_function_glf.py,sha256=RjpVc1jbVSSOuKEAP0S1ir8Vt28DpFWf7RQkUl5i8sQ,14296
+simcats/sensor/barrier_function/_barrier_function_interface.py,sha256=LR6MX9zQQm0SDhoglXcaLLgAIIFXtQOJAMgZ5NJ6buo,1269
+simcats/sensor/barrier_function/_barrier_function_multi_glf.py,sha256=BC93k3h1b7KaiTDsCd2YuqqdgKptUznFmA6JkqnG07w,9101
+simcats/sensor/deformation/__init__.py,sha256=6LZVjyRc1LVcIpBzIX4iI3zwo84NvfBqOiaHE-dq1JU,538
+simcats/sensor/deformation/_sensor_peak_deformation_circle.py,sha256=Q4hsYaZWu2xKB1buMwotPqW2RFe7ddqbN7PDzkiICIw,5264
+simcats/sensor/deformation/_sensor_peak_deformation_interface.py,sha256=48kqIaqCKP358l78viqthMQh0ldvkGyiXW0bUxjB3UU,2450
+simcats/sensor/deformation/_sensor_peak_deformation_linear.py,sha256=3sznbTlpw5Ii0IodczHyeSkQ0gKZLRrPInOdetJmNDg,3199
+simcats/support_functions/__init__.py,sha256=bmc7WrjS-TucMmPq-hk15fZdMWrnRLD7rnk1UZRZ5fI,1762
+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/_generalized_logistic_function.py,sha256=XG8IbO3KMP9KhXpyMs1mFoO6wzd68LOBrf9yIo_4ncA,10229
+simcats/support_functions/_linear_algebra.py,sha256=xV6Eup1DmZBm7fiwPc6qUD0ayIAC2yJQMeq0XnCmWTc,6927
+simcats/support_functions/_parameter_sampling.py,sha256=Dsy_CF143vNEriKNWgZjo06Rfastc-2jKmt96yrDjhc,15304
+simcats/support_functions/_pixel_volt_transformation.py,sha256=qDXK1fRSQrwcpf0b6xA9IC9ott6DdZMeiuQZ3-QSFoA,1060
+simcats/support_functions/_plotting.py,sha256=xc050m4W6RZm8XdOdqruc-6IYyhzW9UFvNlJEgkJRi8,9070
+simcats/support_functions/_reset_offset_mu_sens.py,sha256=YR4Eed3FQIpIjOXrMcaLQJR6eJknKIKQd1OKwpgJGEg,2218
+simcats/support_functions/_rotate_points.py,sha256=4tgzE4a4uykBVw2pSK55DzGe-5n9N38nsBYhfA38Qgs,778
+simcats/support_functions/_signed_dist_points_line.py,sha256=dMnDoBARY7C48xCHFp8mNFNCkPk7YUiaWaRqAsindsE,908
+simcats-2.0.0.dist-info/licenses/LICENSE,sha256=aZs_e2FTt6geKaC1hd9FpoxERpb5YHhxJ608urp4nig,21294
+simcats-2.0.0.dist-info/METADATA,sha256=3lpZyrw5nGv9GqjAluWLm4rNa2aquH6lnAfbaTkvqxA,13908
+simcats-2.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+simcats-2.0.0.dist-info/top_level.txt,sha256=M-ExkkJ_NLsuuJiDo3iM2qPPPsEX29E2MQUmegBZ8Wk,8
+simcats-2.0.0.dist-info/RECORD,,

{simcats-1.1.0.dist-info → simcats-2.0.0.dist-info}/WHEEL

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

simcats-1.1.0.dist-info/RECORD

@@ -1,37 +0,0 @@
-simcats/__init__.py,sha256=v8TOUudnx9Q6cNwoVjZkvmHv3VmZCTqEfR7D5sDbUA0,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=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=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=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=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=cSJXeCLuquzZFoY_dLY4B2nTT08Ngpch1FMfYDzkiSg,1032
-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=0TYceyE3ejLtZZ-ofCJ3icTKFpUvHf1xZycVIbHWxfE,10555
-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.1.0.dist-info/LICENSE,sha256=aZs_e2FTt6geKaC1hd9FpoxERpb5YHhxJ608urp4nig,21294
-simcats-1.1.0.dist-info/METADATA,sha256=u-ZTqGo-9AKHdgQTs7pv_zvqhklIXHlBMja7vK3x0hs,10680
-simcats-1.1.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-simcats-1.1.0.dist-info/top_level.txt,sha256=M-ExkkJ_NLsuuJiDo3iM2qPPPsEX29E2MQUmegBZ8Wk,8
-simcats-1.1.0.dist-info/RECORD,,