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

simcats/config_samplers/__init__.py

@@ -0,0 +1,9 @@
+"""
+Samplers for generating configurations for the Simulation class.
+
+@author: f.hader, b.papajewski
+"""
+
+from simcats.config_samplers._GaAs_v1_random_variations_v3_config_sampler import sample_random_variations_v3_config
+
+__all__ = ["sample_random_variations_v3_config"]

simcats/distortions/_distortion_interfaces.py

@@ -64,7 +64,7 @@ class OccupationDistortionInterface(DistortionInterface):
                 gate.
             volt_limits_g2 (np.ndarray): Contains the beginning and ending of the swept range for the second (plunger)
                 gate.
-            generate_csd (Union[Callable, None]): Function which generates data points outside the swept gate range.
+            generate_csd (Optional[Callable]): Function which generates data points outside the swept gate range.
                 This is especially required for distortions, which shift the CSD structure. The generated data points
                 also have to contain the distortions, which have already been added to the occupation and
                 lead_transitions before. Default is None.

simcats/distortions/_dot_jumps.py

@@ -4,7 +4,7 @@
 """
 
 import warnings
-from typing import Callable, Tuple, Union
+from typing import Callable, Tuple, Union, Optional
 
 import numpy as np
 
@@ -106,7 +106,7 @@ class OccupationDotJumps(OccupationDistortionInterface):
         self.__rng = rng
 
     @property
-    def activated(self) -> Union[bool, None]:
+    def activated(self) -> Optional[bool]:
         """This is true if the noise was activated during the last call of noise function."""
         return self.__activated
 
@@ -139,14 +139,16 @@ class OccupationDotJumps(OccupationDistortionInterface):
                 gate.
             volt_limits_g2 (np.ndarray): Contains the beginning and ending of the swept range for the second (plunger)
                 gate.
-            generate_csd (Union[Callable, None]): Function which generates data points outside the swept gate range.
+            generate_csd (Optional[Callable]): Function which generates data points outside the swept gate range.
                 This is especially required for distortions, which shift the CSD structure. The generated data points
                 also have to contain the distortions, which have already been added to the occupation and
                 lead_transitions before. Defaults to None.
             freeze (bool): Indicates if the last used noise should be reused. This is important if there are noise
                 types which need to generate data from outside the current CSD (for example if a part of the structure
                 is shifted). This newly generated data also has to contain the noise which already has been applied to
-                the CSD before.
+                the CSD before. A use case for that is the application of dot jumps in vertical direction after the
+                application in horizontal direction. Due to the jumps in vertical direction new data might have to be
+                generated with generate_csd. In this data, the horizontal jumps also have to be applied.
 
         Returns:
             Tuple[np.ndarray, np.ndarray]: Occupation numbers and lead transition mask (in our case: total charge
@@ -686,7 +688,7 @@ def dot_jumps_pixelwise(
     original: np.ndarray,
     scale: float,
     lam: float,
-    noise: Union[np.ndarray, None] = None,
+    noise: Optional[np.ndarray] = None,
     rng: np.random.Generator = np.random.default_rng(),
 ) -> Tuple[np.ndarray, np.ndarray]:
     """Adds dot jumps to the original image (pixelwise).
@@ -707,7 +709,7 @@ def dot_jumps_pixelwise(
             this case, scale specifies the length in pixels, so that a jump can start in the middle of a line and end in
             the middle of the next line. Given in pixels.
         lam (float): Lambda for the poisson distribution which specifies the height of the jumps. Given in pixels.
-        noise (Union[np.ndarray, None]): Noise which was generated with this method for a prior image and should be reapplied for
+        noise (Optional[np.ndarray]): Noise which was generated with this method for a prior image and should be reapplied for
             this image. Default is None.
         rng (np.random.Generator): The random number generator used for the simulation of random numbers. Default is
             np.random.default_rng().

simcats/distortions/_random_telegraph_noise.py

@@ -3,7 +3,7 @@
 @author: s.fleitmann
 """
 
-from typing import Union
+from typing import Union, Optional
 
 import numpy as np
 
@@ -102,7 +102,7 @@ class RandomTelegraphNoise(DistortionInterface):
         self.__rng = rng
 
     @property
-    def activated(self) -> Union[bool, None]:
+    def activated(self) -> Optional[bool]:
         """This is true if the noise was activated during the last call of noise function."""
         return self.__activated
 
@@ -149,8 +149,8 @@ class RandomTelegraphNoise(DistortionInterface):
                 )
         else:
             resolution = (original.shape[0], original.shape[0])
-            # sweep direction is always the x-axis direction
-            scale *= resolution[0] / (np.max(volt_limits_g1) - np.min(volt_limits_g1))
+            # sweep between starting and ending point
+            scale *= resolution[0] / np.maximum(np.max(volt_limits_g1) - np.min(volt_limits_g1), np.max(volt_limits_g2) - np.min(volt_limits_g2))
 
         try:
             std = self.std.sample_parameter()

simcats/distortions/_transition_blurring.py

@@ -3,7 +3,7 @@
 @author: s.fleitmann
 """
 
-from typing import Callable, Tuple, Union
+from typing import Callable, Tuple, Union, Optional
 
 import numpy as np
 from scipy.ndimage import gaussian_filter1d
@@ -39,7 +39,7 @@ class OccupationTransitionBlurringFermiDirac(OccupationDistortionInterface):
         self.__sigma = sigma
 
     @property
-    def latest_sigma(self) -> Union[float, None]:
+    def latest_sigma(self) -> Optional[float]:
         """The sigma that was used for the latest simulation.
 
         This is necessary because, depending on the setting, a sampler can be used instead of a fixed sigma.
@@ -75,7 +75,7 @@ class OccupationTransitionBlurringFermiDirac(OccupationDistortionInterface):
                 gate.
             volt_limits_g2 (np.ndarray): Contains the beginning and ending of the swept range for the second (plunger)
                 gate.
-            generate_csd (Union[Callable, None]): Function which generates data points outside the swept gate range.
+            generate_csd (Optional[Callable]): Function which generates data points outside the swept gate range.
                 This is especially required for distortions, which shift the CSD structure. The generated data points
                 also have to contain the distortions, which have already been added to the occupation and
                 lead_transitions before.
@@ -155,7 +155,7 @@ class OccupationTransitionBlurringGaussian(OccupationDistortionInterface):
         self.__sigma = sigma
 
     @property
-    def latest_sigma(self) -> Union[float, None]:
+    def latest_sigma(self) -> Optional[float]:
         """The sigma that was used for the latest simulation.
 
         This is necessary because, depending on the setting, a sampler can be used instead of a fixed sigma.
@@ -191,7 +191,7 @@ class OccupationTransitionBlurringGaussian(OccupationDistortionInterface):
                 gate.
             volt_limits_g2 (np.ndarray): Contains the beginning and ending of the swept range for the second (plunger)
                 gate.
-            generate_csd (Union[Callable, None]): Function which generates data points outside the swept gate range.
+            generate_csd (Optional[Callable]): Function which generates data points outside the swept gate range.
                 This is especially required for distortions, which shift the CSD structure. The generated data points
                 also have to contain the distortions, which have already been added to the occupation and
                 lead_transitions before.

simcats/distortions/_white_noise.py

@@ -3,7 +3,7 @@
 @author: s.fleitmann
 """
 
-from typing import Union
+from typing import Union, Optional
 
 import numpy as np
 
@@ -51,7 +51,7 @@ class SensorResponseWhiteNoise(SensorResponseDistortionInterface):
         self.__rng = rng
 
     @property
-    def latest_sigma(self) -> Union[float, None]:
+    def latest_sigma(self) -> Optional[float]:
         """The sigma that was used for the latest simulation.
 
         This is necessary because, depending on the setting, a sampler can be used instead of a fixed sigma.

simcats/ideal_csd/geometric/_generate_lead_transition_mask.py

@@ -4,7 +4,7 @@ measurements.
 @author: f.hader
 """
 
-from typing import Callable, Dict, Union
+from typing import Callable, Dict, Optional
 
 import numpy as np
 
@@ -48,7 +48,7 @@ def generate_lead_transition_mask_2d(
     volt_limits_g2: np.ndarray,
     tct_functions: Dict[int, Callable],
     rotation: float = -np.pi / 4,
-    lut_entries: Union[int, None] = None,
+    lut_entries: Optional[int] = None,
 ) -> np.ndarray:
     """Generates the ground truth label mask for the lead transitions of 2D scans.
 
@@ -71,7 +71,7 @@ def generate_lead_transition_mask_2d(
             items should be partially initialized versions of the function "tct_bezier".
         rotation (float): The rotation to be applied to the TCT(s) (which is/are usually represented rotated by 45
             degrees). Default is -np.pi/4.
-        lut_entries (Union[int, None]): Number of samples for the lookup-table. If this is not None, a lookup-table will be used to
+        lut_entries (Optional[int]): Number of samples for the lookup-table. If this is not None, a lookup-table will be used to
             evaluate the points on the bezier curve. Default is None.
 
     Returns:

simcats/ideal_csd/geometric/_get_electron_occupation.py

@@ -8,7 +8,7 @@ numbers are calculated without the need for a lead transition mask.
 """
 
 from functools import partial
-from typing import Callable, Dict, Tuple, Union
+from typing import Callable, Dict, Tuple, Optional
 
 # used to find all regions
 import diplib as dip
@@ -86,9 +86,9 @@ def get_electron_occupation(
     bezier_coords: Dict[int, np.ndarray],
     tct_functions: Dict[int, Callable],
     rotation: float = -np.pi / 4,
-    lut_entries: Union[int, None] = None,
+    lut_entries: Optional[int] = None,
     cdf_type: str = "sigmoid",
-    cdf_gamma_factor: Union[float, None] = None,
+    cdf_gamma_factor: Optional[float] = None,
 ) -> np.ndarray:
     """Calculates the electron occupations for a given CSD represented by a numpy array.
 
@@ -113,11 +113,11 @@ def get_electron_occupation(
             system) and the items should be partially initialized versions of the function "tct_bezier".
         rotation (float): The rotation that has been 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 the bezier curves. If this is not
+        lut_entries (Optional[int]): Number of samples for the lookup-table for the bezier curves. If this is not
             None, a lookup-table will be used to evaluate the points on the bezier curve. Default is None.
         cdf_type (str): Name of the type of cumulative distribution function (CDF) to be used for interdot transitions.
             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.
+        cdf_gamma_factor (Optional[float]): The factor used for the calculation of the gamma values of the CDF.
             If set to None, the default values for the selected cdf_type are used (2.2 for sigmoid, 6.15 for cauchy). \n
             Gamma is calculated as follows: \n
             gamma = width_bezier_curve / cdf_gamma_factor. \n

simcats/ideal_csd/geometric/_ideal_csd_geometric.py

@@ -4,7 +4,7 @@ transitions (TCTs), voltage ranges and a desired resolution. It also implements
 @author: f.hader
 """
 
-from typing import List, Tuple, Union
+from typing import List, Tuple, Union, Optional
 
 import numpy as np
 
@@ -25,9 +25,9 @@ def ideal_csd_geometric(
     volt_limits_g2: np.ndarray,
     resolution: Union[int, np.ndarray] = np.array([100, 100]),
     rotation: float = -np.pi / 4,
-    lut_entries: Union[int, None] = None,
+    lut_entries: Optional[int] = None,
     cdf_type: str = "sigmoid",
-    cdf_gamma_factor: Union[float, None] = None,
+    cdf_gamma_factor: Optional[float] = None,
 ) -> Tuple[np.ndarray, np.ndarray]:
     """Generate an ideal Charge Stability Diagram (CSD) based on the supplied parameters.
 
@@ -60,12 +60,12 @@ def ideal_csd_geometric(
             [res_g1, res_g2]
         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
+        lut_entries (Optional[int]): 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.
+        cdf_gamma_factor (Optional[float]): 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. \n
             Gamma is calculated as follows: \n
             gamma = width_bezier_curve / cdf_gamma_factor \n

simcats/ideal_csd/geometric/_ideal_csd_geometric_class.py

@@ -4,7 +4,7 @@ transitions (TCTs), voltage ranges and a desired resolution. It also implements
 @author: f.hader
 """
 
-from typing import List, Tuple, Union
+from typing import List, Tuple, Union, Optional
 
 import numpy as np
 
@@ -21,9 +21,9 @@ class IdealCSDGeometric(IdealCSDInterface):
         self,
         tct_params: List[np.ndarray],
         rotation: float = -np.pi / 4,
-        lut_entries: Union[int, None] = None,
+        lut_entries: Optional[int] = None,
         cdf_type: str = "sigmoid",
-        cdf_gamma_factor: Union[float, None] = None,
+        cdf_gamma_factor: Optional[float] = None,
     ) -> None:
         """Initializes an object of the class for the geometric simulation approach which is based on total charge
         transitions (TCTs).
@@ -42,12 +42,12 @@ class IdealCSDGeometric(IdealCSDInterface):
                 [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
+            lut_entries (Optional[int]): 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
+            cdf_gamma_factor (Optional[float]): 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
@@ -82,14 +82,14 @@ class IdealCSDGeometric(IdealCSDInterface):
         self.__rotation = rotation
 
     @property
-    def lut_entries(self) -> Union[int, None]:
+    def lut_entries(self) -> Optional[int]:
         """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]):
+    def lut_entries(self, lut_entries: Optional[int]):
         self.__lut_entries = lut_entries
 
     @property
@@ -102,14 +102,14 @@ class IdealCSDGeometric(IdealCSDInterface):
         self.__cdf_type = cdf_type
 
     @property
-    def cdf_gamma_factor(self) -> Union[float, None]:
+    def cdf_gamma_factor(self) -> Optional[float]:
         """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]):
+    def cdf_gamma_factor(self, cdf_gamma_factor: Optional[float]):
         self.__cdf_gamma_factor = cdf_gamma_factor
 
     def get_csd_data(

simcats/ideal_csd/geometric/_tct_bezier.py

@@ -9,7 +9,7 @@ import math
 
 # used to check if a single x-value was passed to x_eval
 import numbers
-from typing import Union
+from typing import Union, Optional
 
 import bezier
 import numpy as np
@@ -19,8 +19,8 @@ import sympy
 def tct_bezier(
     tct_params: np.ndarray,
     x_eval: Union[np.ndarray, numbers.Number],
-    lut_entries: Union[int, None] = None,
-    max_peaks: Union[int, None] = None,
+    lut_entries: Optional[int] = None,
+    max_peaks: Optional[int] = None,
 ) -> Union[np.ndarray, numbers.Number]:
     """Evaluates a total charge transition (TCT) with bezier curves and linear parts.
     A TCT separates the region with n electrons and the region with n+1 electrons in the system. The TCTs (series of
@@ -38,9 +38,9 @@ def tct_bezier(
             [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)
         x_eval (Union[np.ndarray, numbers.Number]): X-values for which the function is evaluated or a single x-value.
-        lut_entries (Union[int, None]): Number of samples for the lookup-table. If this is not None, a lookup-table will
+        lut_entries (Optional[int]): Number of samples for the lookup-table. If this is not None, a lookup-table will
             be used to evaluate the points on the bezier curve, else it is solved explicitly. Default is None.
-        max_peaks (Union[int, None]): Limit for the number of peaks of the TCT. If multiple TCTs are supplied, max_peaks
+        max_peaks (Optional[int]): Limit for the number of peaks of the TCT. If multiple TCTs are supplied, max_peaks
             is increased by 1 for every further wavefront. If None, all TCTs have an unlimited number of peaks and no
             outer linear part. Default is None.
 

simcats/sensor/__init__.py

@@ -2,10 +2,14 @@
 SimCATS subpackage containing all functionalities related to the sensor simulation.
 """
 
-from simcats.sensor._sensor_interface import SensorPeakInterface, SensorInterface
-from simcats.sensor._gaussian_sensor_peak import SensorPeakGaussian, sensor_response_gauss
-from simcats.sensor._lorentzian_sensor_peak import SensorPeakLorentzian, sensor_response_lorentz
-from simcats.sensor._generic_sensor import SensorGeneric
+from simcats.sensor._sensor_interface import SensorPeakInterface, SensorRiseInterface, SensorInterface, \
+    SensorScanSensorInterface
+from simcats.sensor._sensor_peak_gaussian import SensorPeakGaussian, sensor_response_gauss
+from simcats.sensor._sensor_peak_lorentzian import SensorPeakLorentzian, sensor_response_lorentz
+from simcats.sensor._sensor_rise_glf import SensorRiseGLF
+from simcats.sensor._sensor_generic import SensorGeneric
+from simcats.sensor._sensor_scan_sensor_generic import SensorScanSensorGeneric
 
-__all__ = ["SensorPeakInterface", "SensorInterface", "SensorPeakGaussian", "SensorPeakLorentzian", "SensorGeneric",
-           "sensor_response_gauss", "sensor_response_lorentz"]
+__all__ = ["SensorPeakInterface", "SensorRiseInterface", "SensorInterface", "SensorScanSensorInterface",
+           "SensorPeakGaussian", "SensorPeakLorentzian", "SensorRiseGLF", "SensorGeneric",
+           "SensorScanSensorGeneric", "sensor_response_gauss", "sensor_response_lorentz"]

simcats/sensor/{_generic_sensor.py → _sensor_generic.py}

@@ -155,7 +155,7 @@ class SensorGeneric(SensorInterface):
     def __repr__(self):
         return (
             self.__class__.__name__
-            + f"(sensor_peak_function={self.__sensor_peak_function}, alpha_dot={self.__alpha_dot}, alpha_gate={self.__alpha_gate}, offset_mu_sens={self.__offset_mu_sens})"
+            + f"(sensor_peak_function={self.__sensor_peak_function}, alpha_dot={repr(self.__alpha_dot)}, alpha_gate={repr(self.__alpha_gate)}, offset_mu_sens={self.__offset_mu_sens})"
         )
 
     def sensor_response(self, mu_sens: np.ndarray) -> np.ndarray:

simcats/sensor/_sensor_interface.py

@@ -1,11 +1,11 @@
 """This module contains functions for simulating the sensor response for a charge stability diagram (CSD) including the
 cross coupling between the sensor and double dot (plunger) gates.
 
-@author: f.hader
+@author: f.hader, b.papajewski
 """
 
 from abc import ABC, abstractmethod
-from typing import List, Union
+from typing import List, Union, Optional
 
 import numpy as np
 
@@ -18,6 +18,17 @@ class SensorPeakInterface(ABC):
     Implementations of the SensorInterface can consist of multiple peaks.
     """
 
+    @property
+    @abstractmethod
+    def mu0(self) -> Optional[float]:
+        """Mu0 of the sensor peak.
+        This property represents the potential value at which the sensor peak reaches its maximum.
+
+        The method is needed for the generation of labels of scans. An example for that is the generation of labels for
+        sensor scans.
+        """
+        raise NotImplementedError()
+
     @abstractmethod
     def sensor_function(self, mu_sens: np.ndarray) -> np.ndarray:
         """This method has to be implemented in every object which should be used as sensor peak function during the simulation of CSDs.
@@ -39,16 +50,48 @@ class SensorPeakInterface(ABC):
         return self.__class__.__name__ + str(self.__dict__)
 
 
+class SensorRiseInterface(ABC):
+    """Interface for all sensor rise functions that model a final rise of the sensor response.
+
+    This type of rise is needed to simulate the rise at the end of a sensor function, that can be observed in sensor
+    scans.
+    """
+
+    @property
+    @abstractmethod
+    def fully_conductive(self) -> float:
+        """Potential value of the point at which the sensor rise reaches its maximum."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def sensor_function(self, mu_sens: np.ndarray, offset: float) -> np.ndarray:
+        """This method has to be implemented in every object which should be used as sensor rise function during the simulation of CSDs.
+
+        This function should return the sensor (rise) values which result from the given electrochemical potential.
+
+        Args:
+            mu_sens (np.ndarray): The sensor potential, stored in a numpy array with the axis mapping to the scan axis.
+            offset (float): Potential value to which the fully conductive point is shifted.
+
+        Returns:
+            np.ndarray: The sensor response (for the corresponding rise), calculated from the given potential. It is
+            stored in a numpy array with the axis mapping to the CSD axis.
+        """
+        raise NotImplementedError()
+
+    def __repr__(self) -> str:
+        return self.__class__.__name__ + str(self.__dict__)
+
+
 class SensorInterface(ABC):
     """Interface for all sensor functions, which are used in the simulation of CSDs."""
 
     @abstractmethod
-    def __init__(
-        self,
-        sensor_peak_function: Union[SensorPeakInterface, List[SensorPeakInterface]],
-        alpha_dot: np.ndarray,
-        alpha_gate: np.ndarray,
-        offset_mu_sens: float,
+    def __init__(self,
+                 sensor_peak_function: Union[SensorPeakInterface, List[SensorPeakInterface]],
+                 alpha_dot: np.ndarray,
+                 alpha_gate: np.ndarray,
+                 offset_mu_sens: float,
     ) -> None:
         """Initializes an object of the class for the simulation of the sensor response for a CSD.
 
@@ -69,7 +112,7 @@ class SensorInterface(ABC):
 
         The electrochemical potential at the sensor should be given as one- or two-dimensional numpy array to this
         function. The parameters for this sensor function should be attributes of this class. This function should
-        return the sensor values which result from the given electrochemical potential.
+        return the sensor response which result from the given electrochemical potential.
 
         Args:
             mu_sens (np.ndarray): The sensor potential, stored in a 2-dimensional numpy array with the axis mapping to
@@ -82,8 +125,10 @@ class SensorInterface(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def sensor_potential(
-        self, occupations: np.ndarray, volt_limits_g1: np.ndarray, volt_limits_g2: np.ndarray
+    def sensor_potential(self,
+                         occupations: np.ndarray,
+                         volt_limits_g1: np.ndarray,
+                         volt_limits_g2: np.ndarray
     ) -> np.ndarray:
         """Simulates the electrochemical potential at the sensing dot.
 
@@ -106,3 +151,111 @@ class SensorInterface(ABC):
 
     def __repr__(self) -> str:
         return self.__class__.__name__ + str(self.__dict__)
+
+
+class SensorScanSensorInterface(SensorInterface):
+    def __init__(self,
+                 sensor_peak_function: Union[SensorPeakInterface, List[SensorPeakInterface], None],
+                 alpha_dot: np.ndarray,
+                 alpha_gate: np.ndarray,
+                 alpha_sensor_gate: np.ndarray,
+                 offset_mu_sens: np.ndarray,
+    ) -> None:
+        """This method initializes an object of the class SensorScanSensorInterface.
+
+        Args:
+            sensor_peak_function (Union[SensorPeakInterface, List[SensorPeakInterface], None]): An implementation of the
+                SensorPeakInterface. It is also possible to supply a list of such peaks, if a sensor with multiple peaks
+                should be simulated.
+            alpha_dot (np.ndarray): Lever-arm of the dots for the sensor potential(s). The values should be negative.
+            alpha_gate (np.ndarray): Lever-arm of the gates for the sensor potential(s). The values should be positive.
+            alpha_sensor_gate (np.ndarray): Lever-arm of the sensor gates for the sensor potential(s). The values should
+                be positive.
+            offset_mu_sens (np.ndarray): Electrochemical potential of the sensor dot for zero electrons in the dots and
+                no applied voltage at the gates.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def sensor_potential(self,
+                         occupations: np.ndarray,
+                         volt_limits_g1: Union[np.ndarray, float, None],
+                         volt_limits_g2: Union[np.ndarray, float, None],
+                         volt_limits_sensor_g1: Union[np.ndarray, float, None],
+                         volt_limits_sensor_g2: Union[np.ndarray, float, None]
+                         ) -> np.ndarray:
+        """Simulates the electrochemical potential at the sensor dot and both barriers.
+
+        This is done in dependency on the electron occupation in the double dot, the voltages applied at the double
+        dot (plunger) gates, and voltages applied at the gates of sensor.
+        Either the double dot gates or the sensor gates can be swept.
+
+        Args:
+            occupations (np.ndarray): Occupation in left and right dot per applied voltage combination. 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.
+            volt_limits_g1 (Union[np.ndarray, float, None]): Voltages applied to the first (plunger) gate of the double
+                dot. When a fixed voltage is applied this is a float and when this gate should be swept it is a numpy
+                array with the minimum and maximum of the sweep.
+            volt_limits_g2 (Union[np.ndarray, float, None]): Voltages applied to the second (plunger) gate of the double
+                dot. When a fixed voltage is applied this is a float and when this gate should be swept it is a numpy
+                array with the minimum and maximum of the sweep.
+            volt_limits_sensor_g1 (Union[np.ndarray, float, None]): Voltages applied to the first sensor gate.
+                When a fixed voltage is applied this is a float and when this gate should be swept it is a numpy array
+                with the minimum and maximum of the sweep.
+            volt_limits_sensor_g2 (Union[np.ndarray, float, None]): voltages applied to the second sensor gate.
+                When a fixed voltage is applied this is a float and when this gate should be swept it is a numpy array
+                with the minimum and maximum of the sweep.
+
+        Returns:
+            np.ndarray: The electrochemical potential of the sensor dot, and both barrier. It is returned as a
+            three-dimensional array with the shape (3, occupations.shape[0], occupations.shape[1]). The first dimension
+            corresponds to the three potentials involved. It is structured as follows:
+            [sensor dot potential, barrier 1 potential, barrier 2 potential]
+            The remaining two dimensions correspond to the swept voltages.
+        """
+        raise NotImplementedError
+
+    def get_sensor_scan_labels(self,
+                               volt_limits_g1: Union[np.ndarray, float, None],
+                               volt_limits_g2: Union[np.ndarray, float, None],
+                               volt_limits_sensor_g1: Union[np.ndarray, float, None],
+                               volt_limits_sensor_g2: Union[np.ndarray, float, None],
+                               potential: np.ndarray) -> np.ndarray:
+        """This method returns the labels of the sensor scans.
+
+        There are two labels for sensor scans: the conductive area mask and the Coulomb peak mask. Both masks are numpy
+        arrays that consist of integers.
+        The conductive area mask marks the non-conductive area, sensor oscillation regime, and fully conductive area.
+        The non-conductive area is marked with 0. This is the area in which no electron can tunnel or flow through the
+        sensor dot. The sensor oscillation regime is the area in which the barriers are open enough for oscillations to
+        occur, as electrons tunnel periodically. This area is marked with 1. In the third area, the conductive area,
+        both barriers are fully open and transport occurs as a continuous current rather than through a well-defined
+        sensor dot. The fully conductive area is marked with 2.
+        The Coulomb peak mask marks the peaks of the Coulomb peak as integers. The wave fronts are marked with values
+        higher or equal to one. All maxima belonging to the same Coulomb peak are marked with the same integer.
+        Depending on the potential value, the various Coulomb peaks are marked with ascending values.
+
+        Args:
+            volt_limits_g1 (Union[np.ndarray, float, None]): Voltages applied to the first double dot (plunger) gate.
+                When a fixed voltage is applied this is a float and when this gate should be swept it is a numpy array
+                with the minimum and maximum of the sweep. None can also be passed if no voltage is applied.
+            volt_limits_g2 (Union[np.ndarray, float, None]): Voltages applied to the second double dot(plunger) gate.
+                When a fixed voltage is applied this is a float and when this gate should be swept it is a numpy array
+                with the minimum and maximum of the sweep. None can also be passed if no voltage is applied.
+            volt_limits_sensor_g1 (Union[np.ndarray, float, None]): Voltages applied to the first sensor gate.
+                When a fixed voltage is applied this is a float and when this gate should be swept it is a numpy array
+                with the minimum and maximum of the sweep. None can also be passed if no voltage is applied.
+            volt_limits_sensor_g2 (Union[np.ndarray, float, None]): Voltages applied to the second sensor gate.
+                When a fixed voltage is applied this is a float and when this gate should be swept it is a numpy array
+                with the minimum and maximum of the sweep. None can also be passed if no voltage is applied.
+            potential (np.ndarray): Numpy array that contains the potential of the area for which labels should be
+                generated. This potential must correspond to the voltages specified for volt_limits_g1,
+                volt_limits_g2, volt_limits_sensor_g1 and volt_limits_sensor_g2.
+
+        Returns:
+            (np.ndarray, np.ndarray): Tuple with the two numpy arrays of the two labels of sensor scan.
+            The returned tuple looks like: (conductive area mask, coulomb peak mask). Both arrays have the same shape
+            as the provided potential.
+        """
+        raise NotImplementedError