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

simcats/sensor/barrier_function/__init__.py

@@ -0,0 +1,9 @@
+"""
+SimCATS subpackage of the sensor package containing all functionalities related to barrier functions.
+"""
+
+from simcats.sensor.barrier_function._barrier_function_interface import BarrierFunctionInterface
+from simcats.sensor.barrier_function._barrier_function_glf import BarrierFunctionGLF
+from simcats.sensor.barrier_function._barrier_function_multi_glf import BarrierFunctionMultiGLF
+
+__all__ = ['BarrierFunctionInterface', 'BarrierFunctionGLF', 'BarrierFunctionMultiGLF']

simcats/sensor/barrier_function/_barrier_function_glf.py

@@ -0,0 +1,280 @@
+"""This module contains a class that models the conductivity of a barrier using the generalized logistic function (GLF).
+
+@author: b.papajewski
+"""
+
+from typing import Union
+
+import numpy as np
+
+from simcats.sensor.barrier_function import BarrierFunctionInterface
+from simcats.support_functions import glf, inverse_glf
+
+__all__ = []
+
+
+class BarrierFunctionGLF(BarrierFunctionInterface):
+    """Implementation of the BarrierFunctionInterface that models a conductivity off of a barrier using a generalized logistic function (GLF).
+
+    For further information see: https://en.wikipedia.org/wiki/Generalised_logistic_function
+    """
+
+    def __init__(self, pinch_off_percentage: float, fully_conductive_percentage: float, asymptote_left: float,
+                 asymptote_right: float, growth_rate: float, asymmetry: float, shape_factor: float,
+                 denominator_offset: float = 1, offset: float = 0):
+        """
+        Initializes an object of the class to represent the barrier function using the generalized logistic function.
+        For further information see: https://en.wikipedia.org/wiki/Generalised_logistic_function
+
+        Args:
+            pinch_off_percentage (float): Percentage of the GLF height before which the barrier response is
+                considered non-conductive. The height is defined as the absolute difference between the two asymptotes.
+            fully_conductive_percentage (float): Percentage of the GLF height after which the barrier response is
+                considered fully conductive. The height is defined as the absolute difference between the two
+                asymptotes.
+            asymptote_left (float): Originally called A. This parameter is the left horizontal asymptote of the
+                function. Any rational number can be used as the left asymptote. This parameter may take any rational
+                number.
+            asymptote_right (float): Originally called K. Specifies the right horizontal asymptote of the function
+                when denominator_offset=1. If asymptote_left=0 and denominator_offset=1 then this parameter is also
+                called the carrying capacity. This parameter may take any rational number.
+            growth_rate (float): Originally called B. The growth rate of the function. The value must be a float and can
+                be any rational number. Be careful with negative values, because the function is mirrored on a vertical
+                straight line for these. This line passes through the point where the potential equals `offset`.
+            asymmetry (float): Originally called nu. This parameter introduces skew and affects symmetry. It also
+                affects near which asymptote maximum growth occurs. The value of asymmetry must be a rational number
+                greater than zero. \n
+                - `asymmetry > 1`: the curve rises more gradually before the midpoint and more sharply after. \n
+                - `asymmetry < 1`: the curve rises quickly early on and levels off more slowly.
+            shape_factor (float): Originally called Q. is related to the value Y(0) and adjusts the curve's value at the
+                y-intercept. Thereby it changes the shape of the function without changing the asymptotes. The shape
+                factor can be any rational number.
+            denominator_offset (float): Originally called C. A constant added to the denominator inside the power.
+                Controls the initial level of the denominator.This parameter must be a rational number. It typically
+                takes a value of 1. Otherwise, the upper asymptote is \n
+                asymptote_left + (asymptote_right-asymptote_left)/(denominator_offset^(1/asymmetry)).
+            offset (float): Potential offset that shifts the GLF starting from the zero point. If the offset is
+                positive, the function is shifted to the right and if it is negative, it is shifted to the left. Default
+                is 0.
+        """
+        self.pinch_off_percentage = pinch_off_percentage
+        self.fully_conductive_percentage = fully_conductive_percentage
+        self.asymptote_left = asymptote_left
+        self.asymptote_right = asymptote_right
+        self.growth_rate = growth_rate
+        self.asymmetry = asymmetry
+        self.shape_factor = shape_factor
+        self.denominator_offset = denominator_offset
+        self.offset = offset
+
+    def get_value(self, potential: Union[float, np.ndarray]) -> float:
+        """Returns the value of the barrier function for a given potential.
+
+        Args:
+            potential (Union[float, np.ndarray]): Potential for which the conductance of the barrier function is to be
+                calculated.
+
+        Returns:
+             Union[float, np.ndarray]: Value of the barrier function for a given potential.
+        """
+        return glf(potential=potential, asymptote_left=self.asymptote_left, asymptote_right=self.asymptote_right,
+                   growth_rate=self.growth_rate, asymmetry=self.asymmetry, shape_factor=self.shape_factor,
+                   denominator_offset=self.denominator_offset, offset=self.offset)
+
+    @property
+    def pinch_off(self) -> float:
+        """Potential value of the pinch off."""
+        return inverse_glf(
+            value=np.abs(self.asymptote_right - self.asymptote_left) * self.pinch_off_percentage + np.min(
+                [self.asymptote_left, self.asymptote_right]),
+            asymptote_left=self.asymptote_left,
+            asymptote_right=self.asymptote_right,
+            growth_rate=self.growth_rate,
+            asymmetry=self.asymmetry,
+            shape_factor=self.shape_factor,
+            denominator_offset=self.denominator_offset,
+            offset=self.offset
+        )
+
+    @property
+    def pinch_off_percentage(self) -> float:
+        """Percentage of the GLF height before which the barrier response is considered non-conductive. The height is
+            defined as the absolute difference between the two asymptotes."""
+        return self.__pinch_off_percentage
+
+    @pinch_off_percentage.setter
+    def pinch_off_percentage(self, pinch_off_percentage: float) -> None:
+        """Updates the pinch of percentage.
+
+        Args:
+            pinch_off_percentage (float): Potential value of the pinch off
+        """
+        self.__pinch_off_percentage = pinch_off_percentage
+
+    @property
+    def fully_conductive(self) -> float:
+        """Potential value of the point from which on the barrier vanishes and becomes fully conductive."""
+        return inverse_glf(
+            value=np.abs(self.asymptote_right - self.asymptote_left) * self.fully_conductive_percentage + np.min(
+                [self.asymptote_left, self.asymptote_right]),
+            asymptote_left=self.asymptote_left,
+            asymptote_right=self.asymptote_right,
+            growth_rate=self.growth_rate,
+            asymmetry=self.asymmetry,
+            shape_factor=self.shape_factor,
+            denominator_offset=self.denominator_offset,
+            offset=self.offset
+        )
+
+    @property
+    def fully_conductive_percentage(self) -> float:
+        """Percentage of the GLF height after which the barrier response is considered fully conductive. The height is
+            defined as the absolute difference between the two asymptotes."""
+        return self.__fully_conductive_percentage
+
+    @fully_conductive_percentage.setter
+    def fully_conductive_percentage(self, fully_conductive_percentage: float) -> None:
+        """Updates the fully conductive percentage.
+
+        Args:
+            fully_conductive_percentage (float): Potential value of the fully conductive point.
+        """
+        self.__fully_conductive_percentage = fully_conductive_percentage
+
+    @property
+    def asymptote_left(self):
+        """Originally called A. This parameter is the left horizontal asymptote of the function. Any rational number can
+        be used as the left asymptote. This parameter may take any rational number.
+        """
+        return self.__asymptote_left
+
+    @asymptote_left.setter
+    def asymptote_left(self, asymptote_left: float) -> None:
+        """Updates the left horizontal asymptote of the GLF.
+
+        Args:
+            asymptote_left (float): Left horizontal asymptote of the GLF. The value must be a float and can be any
+                rational number.
+        """
+        self.__asymptote_left = asymptote_left
+
+    @property
+    def asymptote_right(self):
+        """Originally called K. Specifies the right horizontal asymptote of the function when denominator_offset=1. If
+        asymptote_left=0 and denominator_offset=1 then this parameter is also called the carrying capacity. This
+        parameter may take any rational number.
+        """
+        return self.__asymptote_right
+
+    @asymptote_right.setter
+    def asymptote_right(self, asymptote_right: float) -> None:
+        """Updates the right horizontal asymptote of the GLF.
+
+        Args:
+            asymptote_right (float): Right horizontal asymptote of the GLF. The value must be a float and can be any
+                rational number.
+        """
+        self.__asymptote_right = asymptote_right
+
+    @property
+    def growth_rate(self):
+        """Originally called B. The growth rate of the function. The value must be a float and can´be any rational
+        number. Be careful with negative values, because the function is mirrored on a vertical straight line for these.
+        This line passes through the point where the potential equals `offset`.
+        """
+        return self.__growth_rate
+
+    @growth_rate.setter
+    def growth_rate(self, growth_rate: float) -> None:
+        """Updates the growth rate of the GLF.
+
+        Args:
+            growth_rate (float): Growth rate of the GLF. The value must be a float and can be any rational number.
+        """
+        self.__growth_rate = growth_rate
+
+    @property
+    def asymmetry(self):
+        """Originally called nu. This parameter introduces skew and affects symmetry. It also affects near which
+        asymptote maximum growth occurs. The value of asymmetry must be a rational number greater than zero. \n
+        - If `asymmetry > 1`: the curve rises more gradually before the midpoint and more sharply after. \n
+        - If `asymmetry < 1`: the curve rises quickly early on and levels off more slowly.
+        """
+        return self.__asymmetry
+
+    @asymmetry.setter
+    def asymmetry(self, asymmetry: float) -> None:
+        """Updates asymmetry, which affects near which asymptote maximum growth occurs. The value of asymmetry must be
+        a rational number greater than zero.
+
+        Args:
+            asymmetry (float): Asymmetry of the GLF. The value must be a float and can be any rational number greater
+                than zero.
+        """
+        if asymmetry <= 0:
+            raise ValueError(f"asymmetry should be positive, but was {asymmetry}")
+        self.__asymmetry = asymmetry
+
+    @property
+    def shape_factor(self):
+        """Originally called Q. is related to the value Y(0) and adjusts the curve’s value at the y-intercept. Thereby
+        it changes the shape of the function without changing the asymptotes. The shape factor can be any rational
+        number."""
+        return self.__shape_factor
+
+    @shape_factor.setter
+    def shape_factor(self, shape_factor: float) -> None:
+        """Updates shape_factor, which is related the value Y(0). The value can be any rational number.
+
+        Args:
+            shape_factor (float): Shape factor of the GLF. The value must be a float and can be any rational number.
+        """
+        self.__shape_factor = shape_factor
+
+    @property
+    def denominator_offset(self) -> float:
+        """Originally called C. A constant added to the denominator inside the power. Controls the initial level of the
+        denominator.This parameter must be a rational number. It typically takes a value of 1. Otherwise, the upper
+        asymptote is \n
+        asymptote_left + (asymptote_right-asymptote_left)/(denominator_offset^(1/asymmetry)).
+        """
+        return self.__denominator_offset
+
+    @denominator_offset.setter
+    def denominator_offset(self, denominator_offset: float) -> None:
+        """Originally called C. A constant added to the denominator inside the power. Controls the initial level of the
+        denominator.This parameter must be a rational number. It typically takes a value of 1. Otherwise, the upper
+        asymptote is \n
+        asymptote_left + (asymptote_right-asymptote_left)/(denominator_offset^(1/asymmetry)).
+
+        Args:
+            denominator_offset (float): Denominator offset of the GLF. The value must be a float and can be any rational
+                number.
+       """
+        self.__denominator_offset = denominator_offset
+
+    @property
+    def offset(self) -> float:
+        """Attribute that shifts the GLF starting from the zero point. If the offset is positive, the function is
+        shifted to the right and if it is negative, it is shifted to the left. Default is 0.
+        """
+        return self.__offset
+
+    @offset.setter
+    def offset(self, offset: float) -> None:
+        """Updates the potential offset of the GLF. This value shifts the GLF in relation to the zero point.
+
+        Args:
+            offset (float): Potential offset of the GLF. The value must be a float and can be any rational number.
+        """
+        self.__offset = offset
+
+    def __repr__(self):
+        return (
+                self.__class__.__name__
+                + f"(pinch_off_percentage={self.pinch_off_percentage}, "
+                  f"fully_conductive_percentage={self.fully_conductive_percentage}, "
+                  f"asymptote_left={self.asymptote_left}, asymptote_right={self.asymptote_right}, "
+                  f"growth_rate={self.growth_rate}, asymmetry={self.asymmetry}, shape_factor={self.shape_factor}, "
+                  f"denominator_offset={self.denominator_offset}, offset={self.offset})"
+        )

simcats/sensor/barrier_function/_barrier_function_interface.py

@@ -0,0 +1,43 @@
+"""This module contains an interface that models the conductivity of a sensor dot barrier.
+
+@author: b.papajewski
+"""
+
+__all__ = []
+
+from abc import ABC, abstractmethod
+from typing import Union
+
+import numpy as np
+
+
+class BarrierFunctionInterface(ABC):
+    """
+    Interface that models the conductivity (similar to a pinch-off measurement) of a barrier.
+    """
+
+    @abstractmethod
+    def get_value(self, potential: Union[float, np.ndarray]) -> float:
+        """
+        Returns the value of the barrier function for a given potential.
+
+        Args:
+            potential (Union[float, np.ndarray]): Potential for which the conductance of the barrier function is to be
+                calculated.
+
+        Returns:
+            Union[float, np.ndarray]: Value of the barrier function for a given potential.
+        """
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def pinch_off(self) -> float:
+        """Potential value of the pinch off."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def fully_conductive(self) -> float:
+        """Potential value of the point from which on the barrier vanishes and becomes fully conductive."""
+        raise NotImplementedError

simcats/sensor/barrier_function/_barrier_function_multi_glf.py

@@ -0,0 +1,157 @@
+"""This module contains a class that models the conductivity of a barrier using multiple generalized logistic functions (GLFs).
+
+@author: b.papajewski
+"""
+
+from typing import Union, Tuple
+
+import numpy as np
+
+from simcats.sensor.barrier_function import BarrierFunctionInterface
+from simcats.support_functions import multi_glf
+
+__all__ = []
+
+
+class BarrierFunctionMultiGLF(BarrierFunctionInterface):
+    """
+    Implementation of the BarrierFunctionInterface that models a conductivity off of a barrier using a combination of
+    multiple generalized logistic functions (GLFs).
+    For further information see: https://en.wikipedia.org/wiki/Generalised_logistic_function
+    """
+
+    def __init__(self, pinch_off: float, fully_conductive: float, *params: float):
+        """Initializes an object of the class to represent the barrier function using several generalized logistic functions.
+
+        For further information see: https://en.wikipedia.org/wiki/Generalised_logistic_function
+
+        The number of GLFs is specified by the number of parameters. To do this, the parameter count must be
+        divisible by seven and a GLF is added for every seven other parameters.
+
+        Each GLF has the following parameters: \n
+        - asymptote_left (float): Originally called A. This parameter is the left horizontal asymptote of the function.
+          Any rational number can be used as the left asymptote.
+        - asymptote_right (float): Originally called K. Specifies the right horizontal asymptote of the function when
+          denominator_offset=1. If asymptote_left=0 and denominator_offset=1 then this parameter is also called the
+          carrying capacity. This parameter may take any rational number.
+        - growth_rate (float): Originally called B. The growth rate of the function. The value must be a float and can
+          be any rational number. Be careful with negative values, because the function is mirrored on a vertical
+          straight line for these. This line passes through the point where the potential equals `offset`.
+        - asymmetry (float): Originally called nu. This parameter introduces skew and affects symmetry. It also affects
+          near which asymptote maximum growth occurs. The value of asymmetry must be a rational number greater than
+          zero. \n
+          - If `asymmetry > 1`: the curve rises more gradually before the midpoint and more sharply after. \n
+          - If `asymmetry < 1`: the curve rises quickly early on and levels off more slowly.
+        - shape_factor (float): Originally called Q. is related to the value Y(0) and adjusts the curve’s value at the
+          y-intercept. Thereby it changes the shape of the function without changing the asymptotes. The shape
+          factor can be any rational number.
+        - denominator_offset (float): Originally called C. A constant added to the denominator inside the power.
+          Controls the initial level of the denominator.This parameter must be a rational number. It typically takes a
+          value of 1. Otherwise, the upper asymptote is \n
+          asymptote_left + (asymptote_right - asymptote_left) / (denominator_offset^(1 / asymmetry)).
+        - offset (float): Potential offset, that shifts the function starting from the zero point. If the offset is
+          positive, the function is shifted to the right and if it is negative, it is shifted to the left.
+
+        Args:
+            pinch_off (float): Potential at which the pinch-off of the barrier is located.
+            fully_conductive (float): Potential of the point from which on the barrier function is fully conductive.
+            *params: Additional positional arguments representing the GLF parameters. The number of additional
+                parameters must be divisible by seven and determines the number of GLFs that are used for the Multi-GLF.
+                All parameters consist of sequential groups of seven floats that each represent a single GLF. All
+                individual parameters are described above and are in the same order as they are described.
+        """
+        self.pinch_off = pinch_off
+        self.fully_conductive = fully_conductive
+        self.params = params
+
+    def get_value(self, potential: Union[float, np.ndarray]) -> float:
+        """Returns the value of the barrier function for a given potential.
+
+        Args:
+            potential (Union[float, np.ndarray]): Potential for which the conductance of the barrier function is to be
+                calculated.
+
+        Returns:
+            Union[float, np.ndarray]: Value of the barrier function for a given potential.
+        """
+        return multi_glf(potential, *self.__params)
+
+    @property
+    def pinch_off(self) -> float:
+        """Potential value of the pinch off."""
+        return self.__pinch_off
+
+    @pinch_off.setter
+    def pinch_off(self, pinch_off: float) -> None:
+        """Updates the potential value of the pinch off.
+
+        Args:
+            pinch_off (float): Potential value of the pinch off
+        """
+        self.__pinch_off = pinch_off
+
+    @property
+    def fully_conductive(self) -> float:
+        """Potential value of the point from which on the barrier vanishes and becomes fully conductive."""
+        return self.__fully_conductive
+
+    @fully_conductive.setter
+    def fully_conductive(self, fully_conductive: float) -> None:
+        """Updates the fully conductive point, the potential value at which the barrier vanishes.
+
+        Args:
+            fully_conductive (float): Potential value of the fully conductive point.
+        """
+        self.__fully_conductive = fully_conductive
+
+    @property
+    def params(self) -> Tuple[float]:
+        """Parameters of the multiple GLFs.
+        The number of GLFs is specified by the number of parameters. To do this, the parameter count must be divisible
+        by seven and a GLF is added for every seven other parameters.
+
+        Each GLF has the following parameters: \n
+        - asymptote_left (float): Originally called A. This parameter is the left horizontal asymptote of the function.
+          Any rational number can be used as the left asymptote.
+        - asymptote_right (float): Originally called K. Specifies the right horizontal asymptote of the function when
+          denominator_offset=1. If asymptote_left=0 and denominator_offset=1 then this parameter is also called the
+          carrying capacity. This parameter may take any rational number.
+        - growth_rate (float): Originally called B. The growth rate of the function. The value must be a float and can
+          be any rational number. Be careful with negative values, because the function is mirrored on a vertical
+          straight line for these. This line passes through the point where the potential equals `offset`.
+        - asymmetry (float): Originally called nu. This parameter introduces skew and affects symmetry. It also affects
+          near which asymptote maximum growth occurs. The value of asymmetry must be a rational number greater than
+          zero. \n
+          - If `asymmetry > 1`: the curve rises more gradually before the midpoint and more sharply after. \n
+          - If `asymmetry < 1`: the curve rises quickly early on and levels off more slowly.
+        - shape_factor (float): Originally called Q. is related to the value Y(0) and adjusts the curve’s value at the
+          y-intercept. Thereby it changes the shape of the function without changing the asymptotes. The shape factor can
+          be any rational number.
+        - denominator_offset (float): Originally called C. A constant added to the denominator inside the power.
+          Controls the initial level of the denominator. This parameter must be a rational number. It typically takes a
+          value of 1. Otherwise, the upper asymptote is \n
+          asymptote_left + (asymptote_right - asymptote_left) / (denominator_offset^(1 / asymmetry)).
+        - offset (float): Potential offset, that shifts the function starting from the zero point. If the offset is
+          positive, the function is shifted to the right and if it is negative, it is shifted to the left.
+
+        Returns:
+            The parameters of the multiple GLFs as described above.
+        """
+        return self.__params
+
+    @params.setter
+    def params(self, params: Tuple[float]) -> None:
+        """Updates the parameter list of a multi GLF. A more detailed description of every parameter can be found above.
+
+        Args:
+            params (Tuple[float]): Parameters of the multiple GLFs as described above.
+        """
+        if len(params) % 7 != 0:
+            raise ValueError("The parameter list must be divisible by 7")
+        self.__params = params
+
+    def __repr__(self):
+        return (
+                self.__class__.__name__
+                + f"(pinch_off={self.pinch_off}, fully_conductive={self.fully_conductive}, *params={self.__params}"
+        )

simcats/sensor/deformation/__init__.py

@@ -0,0 +1,9 @@
+"""
+SimCATS subpackage of the sensor package containing all functionalities related to sensor peak deformations.
+"""
+
+from simcats.sensor.deformation._sensor_peak_deformation_interface import SensorPeakDeformationInterface
+from simcats.sensor.deformation._sensor_peak_deformation_circle import SensorPeakDeformationCircle
+from simcats.sensor.deformation._sensor_peak_deformation_linear import SensorPeakDeformationLinear
+
+__all__ = ['SensorPeakDeformationInterface', 'SensorPeakDeformationCircle', 'SensorPeakDeformationLinear']

simcats/sensor/deformation/_sensor_peak_deformation_circle.py

@@ -0,0 +1,109 @@
+"""This module contains the class for simulating a circular deformation of sensor peaks in a scan.
+
+@author: b.papajewski
+"""
+from typing import Union
+
+import numpy as np
+
+from simcats.sensor.deformation import SensorPeakDeformationInterface
+
+__all__ = []
+
+
+class SensorPeakDeformationCircle(SensorPeakDeformationInterface):
+    """Circular deformation implementation of the SensorPeakDeformationInterface."""
+
+    def __init__(self, radius: float) -> None:
+        """Initialization of an object of the class CircleSensorPeakDeformation.
+        This kind of deformation uses a single circle for the deformation of a sensor peak.
+
+        Args:
+            radius (float): Radius of the circle that is used for the deformation. The radius can the positive or
+                negative. If the radius is positive the center of the circle is below mu0 and if it is negative the
+                center is above mu0.
+        """
+        super().__init__()
+
+        self.__radius = radius
+
+    @property
+    def radius(self) -> float:
+        """Returns the radius used for this deformation.
+        Radius is specified in potential values.
+        The radius can the positive or negative. If the radius is positive the center of the circle is below mu0 and if
+        it is negative the center is above mu0.
+
+        Returns:
+            float: Radius of the circular deformation. The wavefront is deformed according to this circle.
+        """
+        return self.__radius
+
+    @radius.setter
+    def radius(self, radius: float) -> None:
+        """Sets the radius of the circular deformation.
+        Radius is specified in potential values.
+        The radius can the positive or negative. If the radius is positive the center of the circle is below mu0 and if
+        it is negative the center is above mu0.
+
+        Args:
+            radius (float): Radius of the circular deformation. The wavefront is deformed according to this circle.
+        """
+        self.__radius = radius
+
+    def calc_mu(self, dist: Union[float, np.ndarray], mu0: float) -> Union[float, np.ndarray]:
+        """
+        Method that calculates the deformed potential value for mu0 of a sensor peak that is moved based on the
+        distance (dist) to a middle line, from which the deformation originates, using a circle. The middle line follows
+        the direction of the sensor peaks (i.e., the sensor dot potential) and is perpendicular to the wavefronts
+        defined by the peaks.
+
+        The center of the circle is either above or below the sensor peak and lies on the middle line. However, it is
+        chosen so that the mu0 value lies on the edge of the circle. To determine the deformation, one of the points of
+        the circle with the given distance to the middle line is used. The deformed mu0 value is the potential value of
+        the point whose potential value is closest to the original mu0 value. If there is no point of the circle that
+        has the given distance (dist) to the middle line, the potential of the point of the circle with the greatest
+        distance to the middle straight line is used.
+
+        Args:
+            dist (Union[float, np.ndarray]): Distance from the middle line, from which the deformation originates. If a
+                point is above the middle line the distance is positive and if it is below, the distance is negative.
+                The parameter can either be a np.ndarray that contains multiple distances or a single distance as a
+                float.
+            mu0 (float): Potential offset for calculation of the deformed potential. Usually this should be the
+                potential offset of the sensor peak, that should be deformed.
+
+        Returns:
+             Union[float, np.ndarray]: Deformed potential value mu0 of a sensor peak. The same type as the type of
+             `dist` is returned.
+        """
+        # Here only positive distances are used as the deformation with a single circle is symmetrical
+        dist = np.abs(dist)
+        # Conversion of the raidus from potential values to voltage values
+        radius_volt = self.__radius / np.linalg.norm(self.sensor.alpha_sensor_gate[0])
+
+        radius_abs = np.abs(radius_volt)
+        sign_radius = np.sign(self.__radius)
+
+        # Prevents division by zero if radius_abs is zero
+        with np.errstate(divide='ignore', invalid='ignore'):
+            angle = np.arcsin(np.clip(dist / radius_abs, -1, 1))
+            cos_angle = np.cos(angle)
+
+        # Calculation of both possible points of the circle that have the distance dist to the middle line
+        temp1 = mu0 - (radius_abs - cos_angle * radius_abs) * sign_radius
+        temp2 = mu0 - radius_volt * np.sign(radius_volt)
+
+        # Selection of the result that is closer to the output mu0
+        result = np.where(dist <= radius_abs, temp1, temp2)
+
+        # If the result is an array with only one element, you can convert it to a scalar
+        if np.isscalar(dist):
+            return result.item()
+        else:
+            return result
+
+    def __repr__(self):
+        return (
+            self.__class__.__name__ + f"(radius={self.radius})"
+        )