simcats-datasets 2.5.0__py3-none-any.whl → 2.6.0__py3-none-any.whl

simcats_datasets/support_functions/get_coulomb_oscillation_area_boundaries.py

@@ -0,0 +1,471 @@
+"""Functions for calculating the Coulomb oscillation area boundaries in sensor scans.
+
+@author: k.havemann
+"""
+from copy import deepcopy
+import math
+from typing import Callable, Dict, List, Tuple, Union, Optional
+
+import numpy as np
+
+from simcats.sensor import SensorScanSensorGeneric
+
+from simcats_datasets.support_functions.clip_line_to_rectangle import (clip_point_line_to_rectangle,
+                                                                       clip_slope_line_to_rectangle,
+                                                                       clip_infinite_slope_line_to_rectangle,
+                                                                       create_rectangle_corners,
+                                                                       is_point_inside_rectangle,
+                                                                       line_intersection)
+
+
+def get_coulomb_oscillation_area_boundaries(metadata: Dict,
+                                            range_sensor_g1: Optional[np.ndarray] = None,
+                                            range_sensor_g2: Optional[np.ndarray] = None,
+                                            ) -> Tuple[np.ndarray, List[str]]:
+    """Function for calculating the boundaries of the Coulomb oscillation area in a sensor scan.
+
+    Calculates only the parts of the bounding box within the specified sensor gate 1 (g1) and gate 2 (g2) ranges
+    (range_sensor_g1, range_sensor_g2). The g1 and g2 pinch-off values are used for the left and lower boundaries and
+    the fully conductive values g1 and g2 are used for the right and upper boundaries.
+    In the 2D case, the boundaries are lines; in the 1D case, they are points.
+
+    Args:
+        metadata: Dictionary with sensor metadata.
+        range_sensor_g1: Range of sensor g1 within which the coulomb oscillation area is calculated.
+            If None, sweep_range_sensor_g1 of the sensor metadata is used.
+        range_sensor_g2: Range of sensor g2 within which the coulomb oscillation area is calculated.
+            If None, sweep_range_sensor_g2 of the sensor metadata is used.
+
+    Returns:
+        np.ndarray, List[str]: Returns an array with the line coordinates (2D)/point coordinates (1D) and list
+            containing strings with corresponding labels. Every row of the array represents one line as
+            [x_start, y_start, x_stop, y_stop] in 2D case and a point as [x, y, x, y] in 1D case. In addition, a list
+            of labels of the calculated boundaries is returned. If both the array and the list are empty, there are no
+            boundaries of the oscillation area inside the given voltage ranges.
+    """
+
+    line_points = []
+    labels = []
+    # list of labels for possible lines within the sensor g1 and g2 ranges
+    label_names = ["sensor_g1_pinch_off", "sensor_g2_fully_conductive",
+                   "sensor_g1_fully_conductive", "sensor_g2_pinch_off"]
+    fixed_voltage = None  # is None if neither of the two gate voltages is fixed during the simulation
+    fixed_g1 = False  # specifies whether voltage at g1 is fixed
+
+    if range_sensor_g1 is None:
+        range_sensor_g1 = deepcopy(metadata["sweep_range_sensor_g1"])
+    if range_sensor_g2 is None:
+        range_sensor_g2 = deepcopy(metadata["sweep_range_sensor_g2"])
+
+    if type(metadata["resolution"]) is int:  # 1D scan
+    # Setting up a two-dimensional voltage space for horizontal and vertical scans
+        if math.isclose(range_sensor_g1[0], range_sensor_g1[1], rel_tol=1e-3):  # vertical scan
+            fixed_voltage = range_sensor_g1[0]
+            fixed_g1 = True
+            range_sensor_g1[0] -= 0.1
+            range_sensor_g1[1] += 0.1
+        elif math.isclose(range_sensor_g2[0], range_sensor_g2[1], rel_tol=1e-3):  # horizontal scan
+            fixed_voltage = range_sensor_g2[0]
+            range_sensor_g2[0] -= 0.1
+            range_sensor_g2[1] += 0.1
+
+    # get rectangle corners of the gate 1 and gate 2 voltage ranges: [bottom_left, bottom_right, top_right, top_left]
+    corners = create_rectangle_corners(range_sensor_g1, range_sensor_g2)
+
+    # get pinch-off and fully conductive values from metadata
+    barrier_potentials = (metadata["sensor"].barrier_functions[0].pinch_off,
+                          metadata["sensor"].barrier_functions[0].fully_conductive,
+                          metadata["sensor"].barrier_functions[1].pinch_off,
+                          metadata["sensor"].barrier_functions[1].fully_conductive)
+
+    # get lever arm from metadata
+    alpha_sensor_gate = metadata["sensor"].alpha_sensor_gate  # 3x2 array
+    alpha_gate = metadata["sensor"].alpha_gate  # 3x2 array
+    alpha_dot = metadata["sensor"].alpha_dot  # 3x2 array
+
+    # get get_csd_data()-method from ideal_csd_config
+    generate_csd = None if metadata["ideal_csd_config"] is None else deepcopy(metadata["ideal_csd_config"].get_csd_data)
+
+    # calculate potential offset for both barrier gates
+    potential_offsets = calc_potential_offset(
+        volt_g1=metadata["volt_g1"],
+        volt_g2=metadata["volt_g2"],
+        alpha_gate=alpha_gate,
+        alpha_dot=alpha_dot,
+        generate_csd=generate_csd,
+        offset_mu_sens=metadata["sensor"].offset_mu_sens
+    )
+
+    # calculate intersection points of oscillation area boundaries (order of points: [g1pinchoff_g2pinchoff,
+    #  g1pinchoff_g2fullyconductive, g1fullyconductive_g2fullyconductive, g1fullyconductive_g2pinchoff] resp.
+    #  [lower_left, upper_left, upper_right, lower_right]
+    intersections = calc_oscillation_area_boundaries_intersect_points(
+        gate_potentials=barrier_potentials,
+        alpha_sensor_gate=alpha_sensor_gate,
+        potential_offset=potential_offsets)
+
+    # save oscillation area boundaries and their labels if they are within the sensor g1 and g2 ranges
+    # oscillation area as a quadrilateral
+    for i in range(4):
+        start_point = intersections[i]
+        end_point = intersections[(i + 1) % 4]
+
+        # use intersection points to extend and clip pinch off lines to the edge of the scan range:
+        if i == 0:
+            # extend pinch-off line gate 1 to the upper edge of the voltage range of gate 2:
+            start_point, end_point = extend_pinch_off_line_to_edge(start_point,
+                                                                   end_point,
+                                                                   rect_corners=corners,
+                                                                   is_gate2=False)
+        elif i == 3:
+            # extend pinch-off line gate 2 to the upper edge of the voltage range of gate 1:
+            start_point, end_point = extend_pinch_off_line_to_edge(start_point,
+                                                                   end_point,
+                                                                   rect_corners=corners,
+                                                                   is_gate2=True)
+        else:
+            # use intersection points to clip each line to the rectangle defined by sensor g1 and g2 ranges
+            start_point, end_point = clip_point_line_to_rectangle(start=start_point,
+                                                                  end=end_point,
+                                                                  rect_corners=corners)
+
+        if start_point is not None and end_point is not None:
+            line_points.append(np.array([start_point[0], start_point[1], end_point[0], end_point[1]]))
+            labels.append(label_names[i])
+
+    # add fully conductive line for triangular oscillation area shape:
+    fully_conductive_point = intersections[2]
+    fully_conductive_slope = - alpha_sensor_gate[0, 0] / alpha_sensor_gate[0, 1]
+    start_point, end_point = clip_infinite_slope_line_to_rectangle(slope=fully_conductive_slope,
+                                                                   point=fully_conductive_point,
+                                                                   rect_corners=corners)
+    if start_point is not None and end_point is not None:
+        # the line always goes from the bottom right to the top left:
+        if start_point[0] < end_point[0]:
+            start_point, end_point = end_point, start_point
+
+        intersect_pinch_off_g1 = None
+        intersect_pinch_off_g2 = None
+        if "sensor_g1_pinch_off" in labels:
+            pinch_off_g1_start = line_points[labels.index("sensor_g1_pinch_off")][:2]
+            pinch_off_g1_end = line_points[labels.index("sensor_g1_pinch_off")][2:]
+            intersect_pinch_off_g1 = line_intersection(p1=start_point, p2=end_point,
+                                                       q1=pinch_off_g1_start, q2=pinch_off_g1_end)
+
+        if "sensor_g2_pinch_off" in labels:
+            pinch_off_g2_start = line_points[labels.index("sensor_g2_pinch_off")][:2]
+            pinch_off_g2_end = line_points[labels.index("sensor_g2_pinch_off")][2:]
+            intersect_pinch_off_g2 = line_intersection(p1=start_point, p2=end_point,
+                                                       q1=pinch_off_g2_start, q2=pinch_off_g2_end)
+
+        if intersect_pinch_off_g1 is not None and is_point_inside_rectangle(intersect_pinch_off_g1,
+                                                                            rect_corners=corners):
+            end_point = intersect_pinch_off_g1
+        if intersect_pinch_off_g2 is not None and is_point_inside_rectangle(intersect_pinch_off_g2,
+                                                                            rect_corners=corners):
+            start_point = intersect_pinch_off_g2
+        # else: no change in start and end points
+
+        line_points.append(np.array([start_point[0], start_point[1], end_point[0], end_point[1]]))
+        labels.append("sensor_potential_fully_conductive")
+
+    # 1D Scans: convert lines of the two-dimensional voltage space to points in the one-dimensional measurement
+    if type(metadata["resolution"]) is int:
+        if fixed_voltage is not None:  # scan is either horizontal or vertical
+            if fixed_g1:
+                range_sensor_g1[0] = fixed_voltage
+                range_sensor_g1[1] = fixed_voltage
+            else:
+                range_sensor_g2[0] = fixed_voltage
+                range_sensor_g2[1] = fixed_voltage
+
+        line_points, labels = calc_track_boundaries_intersect_points(volt_range_g1=range_sensor_g1,
+                                                                     volt_range_g2=range_sensor_g2,
+                                                                     line_points=np.array(line_points),
+                                                                     labels=labels)
+
+    return np.array(line_points), labels
+
+
+def extend_pinch_off_line_to_edge(start: Tuple[float, float],
+                                  end: Tuple[float, float],
+                                  rect_corners: List[Tuple[float, float]],
+                                  is_gate2: bool) -> Tuple[Tuple[float, float], Tuple[float, float]]:
+    """Extend and clip the pinch-off line segment to the edge of the voltage ranges of the sensor scan.
+
+    The pinch-off lines are calculated as segments between the lower left corner of the oscillation range and the fully
+    conductive values of the gates. However, the lines are required beyond the fully conductive value up to the upper
+    edge of the voltage ranges of the two gates and are simultaneously trimmed to these.
+
+    Args:
+        start (Tuple[float, float]): The start point of the line segment ((x_start, y_start)).
+        end (Tuple[float, float]): The end point of the line segment ((x_end, y_end)).
+        rect_corners (np.ndarray): The corners of the boundary of the sensor scan.
+        is_gate2 (bool): True if the sensor scan line segment is the pinch-off line for gate 2. False if the sensor scan
+            line segment is the pinch-off line for gate 1.
+
+    Returns:
+        Tuple[Tuple[float, float], Tuple[float, float]]: Extended pinch-off line ((x_start, y_start), (x_end, y_end)).
+    """
+    # If necessary, swap the start and end points:
+    if (is_gate2 and start[0] > end[0]) or (not is_gate2 and start[1] > end[1]):
+        start, end = end, start
+
+    den = start[0] - end[0]
+    if math.isclose(den, 0.0):  # vertical line with infinte slope
+        end = (end[0], np.max([corner[1] for corner in rect_corners]))
+    else:  # all other cases
+        slope = (start[1] - end[1]) / den
+        start, end = clip_slope_line_to_rectangle(slope=slope,
+                                                  point=start,
+                                                  rect_corners=rect_corners,
+                                                  is_start=is_gate2)
+
+    return start, end
+
+
+def calc_oscillation_area_boundaries_intersect_points(gate_potentials: List[float],
+                                                      alpha_sensor_gate: np.ndarray,  # 3x2 array
+                                                      potential_offset: Tuple[float, float],
+                                                      ) -> List[Tuple[float, float]]:
+    """Function for calculating the 4 intersection point of the boundaries of the coulomb oscillation area.
+
+    Args:
+        gate_potentials: List containing pinch-off and fully conductive potentials of sensor gate 1 and gate 2.
+            Assumes it contains exactly 4 values in the specified order:
+            [g1_pinch_off, g1_fully_conductive, g2_pinch_off, g2_fully_conductive]
+        alpha_sensor_gate: Lever arm from the sensor dot (barrier) gates to the sensor potential.
+        potential_offset: Potential offset of the sensor barrier gates.
+
+    Returns:
+        List[Tuple[float, float]]: List of intersection points as Tuples (x_coord, y_coord).
+    """
+    intersection_points = []
+
+    if math.isclose(alpha_sensor_gate[1, 1], 0.0):  # case: slope of gate 1 line is infinity
+        v1_pinch_off = (gate_potentials[0] - potential_offset[0]) / alpha_sensor_gate[1, 0]
+        v1_fully_conductive = (gate_potentials[1] - potential_offset[0]) / alpha_sensor_gate[1, 0]
+
+        v2_pinch_off_left = ((-alpha_sensor_gate[2, 0] * v1_pinch_off + gate_potentials[2] -
+                              potential_offset[1]) / alpha_sensor_gate[2, 1])
+        v2_pinch_off_right = ((-alpha_sensor_gate[2, 0] * v1_fully_conductive + gate_potentials[2] -
+                               potential_offset[1]) / alpha_sensor_gate[2, 1])
+        v2_fully_conductive_left = ((-alpha_sensor_gate[2, 0] * v1_pinch_off + gate_potentials[3] -
+                                     potential_offset[1]) / alpha_sensor_gate[2, 1])
+        v2_fully_conductive_right = ((-alpha_sensor_gate[2, 0] * v1_fully_conductive + gate_potentials[3] -
+                                      potential_offset[1]) / alpha_sensor_gate[2, 1])
+
+        intersection_points = [(v1_pinch_off, v2_pinch_off_left),  # g1pinchoff_g2pinchoff
+                               (v1_pinch_off, v2_fully_conductive_left),  # g1pinchoff_g2fullyconductive
+                               (v1_fully_conductive, v2_fully_conductive_right),  # g1fullyconductive_g2fullyconductive
+                               (v1_fully_conductive, v2_pinch_off_right)]  # g1fullyconductive_g2pinchoff
+
+    else:
+        gate1_potentials = [val for val in gate_potentials[:2] for _ in range(2)]
+        # gate1_potentials: [g1_pinch_off, g1_pinch_off, g1_fully_conductive, g1_fully_conductive]
+        gate2_potentials = gate_potentials[2:] + gate_potentials[:1:-1]
+        # gate2_potentials: [g2_pinch_off, g2_fully_conductive, g2_fully_conductive, g2_pinch_off]
+        for g1_pot, g2_pot in zip(gate1_potentials, gate2_potentials):
+            v1 = (((g2_pot - potential_offset[1]) * alpha_sensor_gate[1, 1]
+                   - (g1_pot - potential_offset[0]) * alpha_sensor_gate[2, 1]) /
+                  (alpha_sensor_gate[2, 0] * alpha_sensor_gate[1, 1]
+                   - alpha_sensor_gate[1, 0] * alpha_sensor_gate[2, 1]))
+            v2 = (-alpha_sensor_gate[1, 0] * v1 + (g1_pot - potential_offset[0])) / alpha_sensor_gate[1, 1]
+            intersection_points.append((v1.item(), v2.item()))
+    # intersection points as Tuples [g1pinchoff_g2pinchoff, g1pinchoff_g2fullyconductive,
+    #  g1fullyconductive_g2fullyconductive, g1fullyconductive_g2pinchoff] resp.
+    #  [lower_left, upper_left, upper_right, lower_right]
+    return intersection_points
+
+
+def calc_potential_offset(volt_g1: float,
+                          volt_g2: float,
+                          alpha_gate: np.ndarray,
+                          alpha_dot: np.ndarray,
+                          generate_csd: Callable[
+                                   [np.ndarray, np.ndarray, Union[int, np.ndarray]], Tuple[np.ndarray, np.ndarray]],
+                          offset_mu_sens: np.ndarray
+                          ) -> Tuple[float, float]:
+    """Function for calculating the potential offset of the barrier gates of a sensor, which is given by the double dot
+    configurations.
+
+    Args:
+        volt_g1: Voltage of the double dot (plunger) gate 1.
+        volt_g2: Voltage of the double dot (plunger) gate 2.
+        alpha_gate: Lever arms from the double dot (plunger) gates to the sensor potential.
+        alpha_dot: Lever arms from the double dot occupations gates to the sensor potential.
+        generate_csd: Method for retrieving ideal data (occupancy numbers and a lead transition mask) for given gate
+            voltages.
+        offset_mu_sens: The potential offset for the sensor.
+
+    Returns:
+        Tuple(float, float): Potential offset of the sensor barrier gates potential (barrier1_off, barrier2_off).
+    """
+
+    if volt_g1 is None or volt_g2 is None:
+        return (0.0, 0.0)
+    else:
+        offset1 = volt_g1 * alpha_gate[1, 0] + volt_g2 * alpha_gate[1, 1] + offset_mu_sens[1]
+        offset2 = volt_g1 * alpha_gate[2, 0] + volt_g2 * alpha_gate[2, 1] + offset_mu_sens[2]
+        if generate_csd is not None:
+            # get double dot occupations
+            occupations_csd, lead_transitions = generate_csd(
+                volt_limits_g1=(volt_g1, volt_g1), volt_limits_g2=(volt_g2, volt_g2), resolution=(1)
+            )
+
+            offset1 += alpha_dot[1, 0] * occupations_csd[0, 0] + alpha_dot[1, 1] * occupations_csd[0, 1]
+            offset2 += alpha_dot[2, 0] * occupations_csd[0, 0] + alpha_dot[2, 1] * occupations_csd[0, 1]
+
+        return (offset1, offset2)
+
+
+def calc_sensor_potential(sensor: SensorScanSensorGeneric,
+                          sweep_range_sensor_g1: Union[np.ndarray, float],
+                          sweep_range_sensor_g2: Union[np.ndarray, float],
+                          resolution: Union[int, np.ndarray],
+                          volt_g1: Optional[float] = None,
+                          volt_g2: Optional[float] = None,
+                          generate_csd: Optional[Callable[[np.ndarray, np.ndarray, Union[int, np.ndarray]], Tuple[np.ndarray, np.ndarray]]] = None) -> np.ndarray:
+    """Function for calculating the sensor potential.
+
+    Calculating the sensor potential for ranges of voltages of the two sensor barrier gates.
+
+    Args:
+        sensor (SensorScanSensorGeneric): Sensor for which the potential is to be calculated.
+        sweep_range_sensor_g1 (np.ndarray): Voltage sweep range of sensor gate 1 (second-/x-axis). \n
+            Example: \n
+            [min_V1, max_V1]
+        sweep_range_sensor_g2 (np.ndarray): Voltage sweep range of sensor gate 2 (first-/y-axis). \n
+            Example: \n
+            [min_V1, max_V1]
+        resolution (Union[int, np.ndarray]): Resolution of the sensor scan.
+        volt_g1 (Optional[float]): Voltage applied at (plunger) gate 1 (second-/x-axis).
+        volt_g2 (Optional[float]): Voltage applied at (plunger) gate 2 (first-/y-axis).
+        generate_csd: Method for retrieving ideal data (occupancy numbers and a lead transition mask) for given gate
+            voltages.
+
+    Returns:
+        np.ndarray: The sensor potential for different sensor barrier gate voltages as an array.
+    """
+    if generate_csd is None or volt_g1 is None or volt_g2 is None:
+        if type(resolution) == int:
+            occupations = np.zeros((resolution, 2))
+        else:
+            occupations = np.zeros((resolution[1], resolution[0], 2))
+    else:
+        # Perform simulation
+        occupations_csd, lead_transitions = generate_csd(
+            volt_limits_g1=(volt_g1, volt_g1), volt_limits_g2=(volt_g2, volt_g2), resolution=(1)
+        )
+
+        if type(resolution) == int:
+            occupations = np.ones((resolution, 2))
+            occupations[:, 0] = occupations[:, 0] * occupations_csd[0, 0]
+            occupations[:, 1] = occupations[:, 1] * occupations_csd[0, 1]
+        else:
+            occupations = np.ones((resolution[1], resolution[0], 2))
+            occupations[:, :, 0] = occupations[:, :, 0] * occupations_csd[0, 0]
+            occupations[:, :, 1] = occupations[:, :, 1] * occupations_csd[0, 1]
+
+    # calculate the sensor potential from the distorted occupations
+    potential = sensor.sensor_potential(
+        occupations=occupations, volt_limits_g1=volt_g1, volt_limits_g2=volt_g2,
+        volt_limits_sensor_g1=sweep_range_sensor_g1, volt_limits_sensor_g2=sweep_range_sensor_g2
+    )[0]  # choose sensor potential from [sensor dot potential, barrier 1 potential, barrier 2 potential]
+
+    return potential
+
+
+def calc_fully_conductive_potential(metadata: Dict) -> float:
+    """Function for calculating the sensor potential at the fully conductive point.
+
+    First determining the fully conductive point in the two-dimensional voltage space, then calculating the potential.
+
+    Args:
+        metadata: Dictionary with sensor metadata.
+
+    Returns:
+        float: The sensor potential at the fully conductive point.
+    """
+    # get pinch-off and fully conductive values from metadata
+    barrier_potentials = (metadata["sensor"].barrier_functions[0].pinch_off,
+                          metadata["sensor"].barrier_functions[0].fully_conductive,
+                          metadata["sensor"].barrier_functions[1].pinch_off,
+                          metadata["sensor"].barrier_functions[1].fully_conductive)
+
+    # get get_csd_data()-method from ideal_csd_config
+    generate_csd = None if metadata["ideal_csd_config"] is None else deepcopy(metadata["ideal_csd_config"].get_csd_data)
+
+    # calculate potential offset for both barrier gates
+    potential_offsets = calc_potential_offset(
+        volt_g1=metadata["volt_g1"],
+        volt_g2=metadata["volt_g2"],
+        alpha_gate=metadata["sensor"].alpha_gate,
+        alpha_dot=metadata["sensor"].alpha_dot,
+        generate_csd=generate_csd,
+        offset_mu_sens=metadata["sensor"].offset_mu_sens
+    )
+
+    # calculation of fully conductive point in two-dimensional voltage space
+    fully_conductive = calc_oscillation_area_boundaries_intersect_points(
+        gate_potentials=barrier_potentials,
+        alpha_sensor_gate=metadata["sensor"].alpha_sensor_gate,
+        potential_offset=potential_offsets)[2]
+
+    # calculation of the sensor potential at the fully conductive point
+    fully_conductive_potential = calc_sensor_potential(sensor=metadata["sensor"],
+                                                       sweep_range_sensor_g1=fully_conductive[0],
+                                                       sweep_range_sensor_g2=fully_conductive[1],
+                                                       resolution=1,
+                                                       volt_g1=metadata["volt_g1"],
+                                                       volt_g2=metadata["volt_g2"],
+                                                       generate_csd=generate_csd)[0]  # choose value from array
+
+    return fully_conductive_potential
+
+
+def calc_track_boundaries_intersect_points(volt_range_g1: np.ndarray,
+                                           volt_range_g2: np.ndarray,
+                                           line_points: np.ndarray,
+                                           labels: List[Dict]) -> Tuple[np.ndarray, List[str]]:
+    """Calculates the intersection points of a one-dimensional, straight measurement track with the boundaries of the
+    Coulomb oscillation area in the two-dimensional sensor data space.
+
+    Args:
+        volt_range_g1 (np.ndarray): Range of sensor g1 of the one-dimensional measurement.
+        volt_range_g2 (np.ndarray): Range of sensor g2 of the one-dimensional measurement.
+        line_points (np.ndarray): Array containing all start and end points of the boundaries of the Coulomb
+            oscillation area. Every row of the array represents one line as [x_start, y_start, x_stop, y_stop].
+        labels (List[str]): Dictionary containing labels for each boundary of the Coulomb oscillation area given in
+            line_points.
+
+    Returns:
+        Tuple[np.ndarray, List[Dict]]: Returns an array of the intersection points of the one-dimensional, straight
+            measurement track with the boundaries of the Coulomb oscillation area. Each row of the array represents one
+            intersection point.
+            In addition, a list of labels of the calculated intersection points is returned.
+            If both the array and the List are empty, there are no intersections.
+    """
+    intersect_points = []
+    point_labels = []
+
+    # Calculate line coordinates of the track of the 1D scan:
+    track_start = (volt_range_g1[0], volt_range_g2[0])
+    track_end = (volt_range_g1[-1], volt_range_g2[-1])
+
+    # measurement is horizontal or vertical:
+    if math.isclose(volt_range_g1[-1], volt_range_g1[0]) or math.isclose(volt_range_g2[-1], volt_range_g2[0]):
+        for i, line in enumerate(line_points):
+            intersect_points.append(line[:2])
+            point_labels.append(labels[i])
+    else:
+        for i, line in enumerate(line_points):
+            # calculation intersection point:
+            intersection = line_intersection(p1=(line[0], line[1]), p2=(line[2], line[3]), q1=track_start, q2=track_end)
+
+            if intersection is not None:
+                # append point (x, y) as line format [x, y, x, y]
+                intersect_points.append(np.array([intersection[0], intersection[1], intersection[0], intersection[1]]))
+                point_labels.append(labels[i])
+
+    return np.array(intersect_points), point_labels

simcats_datasets/support_functions/metadata_utils.py

@@ -0,0 +1,62 @@
+"""Functions for handling metadata, e.g. reconstruct the dtypes of metadata loaded from h5 files.
+
+@author: k.havemann
+"""
+import warnings
+from copy import deepcopy
+from typing import Dict
+
+import numpy as np
+
+# required for eval to work
+from numpy import array
+from simcats.sensor import SensorGeneric, SensorScanSensorGeneric, SensorPeakLorentzian, SensorRiseGLF
+from simcats.sensor.barrier_function import BarrierFunctionGLF
+from simcats.ideal_csd import IdealCSDGeometric
+from simcats.distortions import OccupationDotJumps
+
+
+def reconstruct_metadata_types(metadata: Dict) -> Dict:
+    """Reconstruct metadata types from the sensor metadata dictionary.
+
+    Args:
+        metadata: Dictionary with sensor metadata.
+
+    Returns:
+        Dict: Dictionary with sensor metadata with reconstructed data types.
+    """
+    meta = deepcopy(metadata)
+    if isinstance(meta["resolution"], str):  # 1D
+        meta["resolution"] = int(meta["resolution"])
+
+    meta["sweep_range_sensor_g1"] = np.array(meta["sweep_range_sensor_g1"])
+    meta["sweep_range_sensor_g2"] = np.array(meta["sweep_range_sensor_g2"])
+
+    if isinstance(meta["sensor"], str):
+        meta["sensor"] = eval(meta["sensor"])
+
+    if isinstance(meta["ideal_csd_config"], str):
+        meta["ideal_csd_config"] = eval(meta["ideal_csd_config"])
+
+    meta["volt_g1"] = float(meta["volt_g1"]) if meta["volt_g1"] != "None" else None
+    meta["volt_g2"] = float(meta["volt_g2"]) if meta["volt_g2"] != "None" else None
+
+    if meta["volt_limits_sensor_g1"] is not None:
+        meta["volt_limits_sensor_g1"] = np.array(meta["volt_limits_sensor_g1"])
+    else:
+        meta["volt_limits_sensor_g1"] = np.array([-1.0, 0.0])
+        warnings.warn(
+            f"No voltage limits are specified for the sensor gate 1 in the metadata. "
+            f"[-1.0; 0.0] is used as the voltage limits for sensor gate 1. "
+            f"This may not be consistent with the scan configuration.")
+
+    if meta["volt_limits_sensor_g2"] is not None:
+        meta["volt_limits_sensor_g2"] = np.array(meta["volt_limits_sensor_g2"])
+    else:
+        meta["volt_limits_sensor_g2"] = np.array([-1.0, 0.0])
+        warnings.warn(
+            f"No voltage limits are specified for the sensor gate 2 in the metadata. "
+            f"[-1.0; 0.0] is used as the voltage limits for sensor gate 2. "
+            f"This may not be consistent with the scan configuration.")
+
+    return meta