Magnets module

class Magnet(Registry):
    """Magnet base class


    Returns:
        Magnet: magnet base class
    """

    tol = MAG_TOL  # tolerance for rotations, sufficient for 0.01 degree accuracy
    mag_type = "Magnet"

    def __init__(self, *args, **kwargs):
        super().__init__()
        self.center = _np.array([0.0, 0.0])

class Registry:
    """Registry class for tracking instances

    Instances are tracked in `class.instances` using weak references.
    This also includes any instances that are deleted manually or go out of
    scope.

    Class methods:

        `print_instances()`

        `get_instances()`

        `get_num_instances()`

        `reset()
    """

    instances = WeakSet()
    _class_instances = []

    def __new__(cls, *args, **kwargs):
        o = object.__new__(cls)
        cls._register_instance(o)
        return o

    def __init__(self, *args, **kwargs) -> None:
        super().__init__()
        self.__class__._class_instances.append(self)

    def __del__(self) -> None:
        if self in self.__class__._class_instances:
            self.__class__._class_instances.remove(self)

    @classmethod
    def print_instances(cls):
        """Prints class instantiations"""
        if len(cls.instances) < 1:
            print("No Instances")
        else:
            for instance in cls.instances:
                print(instance)

    @classmethod
    def get_instances(cls):
        """Gets lists of instances

        Returns:
            set: all class instances
        """
        return cls.instances

    @classmethod
    def get_num_instances(cls, Print_Val=False):

        """Return number of instances of class

        Args:
            Print_Val (bool, optional): [Print to screen]. Defaults to False.

        Returns:
            num_instances [int]:
        """
        if Print_Val:
            print(len(cls.instances))
        return len(cls.instances)

    @classmethod
    def _register_instance(cls, instance):
        """Adds class instance to registry

        Args:
            instance (instance): class instance
        """
        cls.instances.add(instance)
        for b in cls.__bases__:
            if issubclass(b, Registry):
                b._register_instance(instance)

    @classmethod
    def reset(cls):
        """Removes all instances from registry."""
        for magnet in cls._class_instances:
            del magnet
        cls.instances = WeakSet()
        cls._class_instances = []

    def __init_subclass__(cls):
        cls.instances = WeakSet()
        cls._class_instances = []

class Circle(Magnet2D):
    """Circle 2D Magnet Class"""

    mag_type = "Circle"

    def __init__(
        self,
        radius=10,
        Jr=1.0,  # local magnetisation
        **kwargs,
    ):
        """Init Method

        Args:
            radius (float, optional): Radius. Defaults to 10.0.
            Jr (float, optional): Remnant magnetisation. Defaults to 1.0.

        Kwargs:
            alpha (float): Unused. For rotations use phi instead
            center (tuple or ndarray): magnet center (x, y). Defaults to (0,0)
            phi (float): Rotation Angle (in degrees) of magnet w.r.t x-axis. Defaults to 90.
        """
        super().__init__(Jr, **kwargs)
        self.radius = radius
        self.phi = kwargs.pop("phi", 0)
        self.phi_rad = _np.deg2rad(self.phi)

        self.Jx = _np.around(Jr * _np.cos(self.phi_rad), decimals=6)
        self.Jy = _np.around(Jr * _np.sin(self.phi_rad), decimals=6)
        self.tol = MAG_TOL  # sufficient for 0.01 degree accuracy

        self.center = kwargs.pop("center", _np.array([0.0, 0.0]))
        self.center = _np.asarray(self.center)

    def __str__(self):
        str = (
            f"{self.__class__.mag_type}\n"
            + f"J: {self.get_Jr()} (T)\n"
            + f"Size: {self.get_size()}\n"
            + f"Center {self.get_center()}\n"
            + f"Orientation: alpha {self.get_orientation()}\n"
        )
        return str

    def __repr__(self):
        str = (
            f"{self.__class__.mag_type}\n"
            + f"J: {self.get_Jr()} (T)\n"
            + f"Size: {self.get_size()}\n"
            + f"Center {self.get_center()}\n"
            + f"Orientation: alpha {self.get_orientation()}\n"
        )
        return str

    def get_size(self):
        """Returns radius

        Returns:
            ndarray: radius
        """
        return _np.array([self.radius])

    def get_Jr(self):
        """Returns signed remnant magnetisation

        Returns:
            ndarray: remnant magnetisation
        """
        return _np.array([self.Jx, self.Jy])

    def get_field(self, x, y):
        """Calculates the magnetic field due to long bipolar cylinder

        Args:
            x (ndarray): x coordinates
            y (ndarray): y coordinates

        Returns:
            tuple: Bx, By magnetic field in cartesian coordinates
        """
        from ..utils._conversions import cart2pol, vector_pol2cart
        from ..utils._routines2D import rotate_points_2D

        if _np.fabs(self.alpha_radians) > Magnet2D.tol:
            xi, yi = rotate_points_2D(
                x - self.center[0], y - self.center[1], self.alpha_radians
            )

            rho, phi = cart2pol(xi, yi)
            Brho, Bphi = self._calcB_polar(rho, phi - self.phi_rad)

            # Convert magnetic fields from cylindrical to cartesian
            Bx, By = vector_pol2cart(Brho, Bphi, phi)
            Bx, By = rotate_points_2D(Bx, By, 2 * PI - self.alpha_radians)
            return Bx, By

        rho, phi = cart2pol(x - self.center[0], y - self.center[1])

        Brho, Bphi = self._calcB_polar(rho, phi - self.phi_rad)

        # Convert magnetic fields from cylindrical to cartesian
        Bx, By = vector_pol2cart(Brho, Bphi, phi)

        return Bx, By

    def _calcB_polar(self, rho, phi):
        """Calculates the magnetic field due to long bipolar cylinder in polar
        coordinates

        Args:
            rho (ndarray): radial values
            phi (ndarray): azimuthal values

        Returns:
            tuple: Br, Bphi magnetic field in polar coordinates
        """
        prefac = self.Jr * (self.radius ** 2 / rho ** 2) / 2

        Brho = prefac * _np.cos(phi)
        Bphi = prefac * _np.sin(phi)

        return Brho, Bphi

class Magnet2D(Magnet):
    """2D Magnet Base Class"""

    mag_type = "Magnet2D"

    def __init__(self, Jr, **kwargs) -> None:
        """Init Method

        Args:
            Jr (float): signed magnetised of remnant magnetisation

        Kwargs:
            alpha (float): Magnetisation orientation angle (in degrees). Defaults to 0.
            center (tuple or ndarray): magnet center (x, y). Defaults to (0,0).
        """
        super().__init__()
        self.Jr = Jr

        # Magnet rotation w.r.t. x-axis
        self.alpha = kwargs.pop("alpha", 0.0)
        self.alpha_radians = _np.deg2rad(self.alpha)

        self.center = kwargs.pop("center", _np.array([0.0, 0.0]))
        self.center = _np.asarray(self.center)

    def get_center(self):
        """Returns magnet centre

        Returns:
            center (ndarray): numpy array [xc, yc]
        """
        return self.center

    def get_orientation(self):
        """Returns magnet orientation, `alpha` in degrees

        Returns:
            float: alpha, rotation angle w.r.t x-axis.
        """

        return self.alpha

    def get_field(self):
        """Calculates the magnetic field.

        This is a template that needs to be implemented for each magnet
        """
        pass

    def get_force_torque(self):
        """Calculates the force and torque on a magnet due to all other magnets.

        This is a template that needs to be implemented for each magnet.
        """
        pass

class Rectangle(Magnet2D):
    """Rectangular 2D Magnet Class"""

    mag_type = "Rectangle"

    def __init__(self, width=20.0, height=40.0, Jr=1.0, **kwargs):
        """Init Method

        Args:
            width (float, optional): Magnet Width. Defaults to 20.0.
            height (float, optional): Magnet Height. Defaults to 40.0.
            Jr (float, optional): Remnant Magnetisation. Defaults to 1.0.

        Kwargs:
            alpha (float): Magnetisation orientation angle (in degrees). Defaults to 0.
            center (tuple or ndarray): magnet center (x, y). Defaults to (0,0).
            phi (float): Rotation Angle (in degrees) of magnet w.r.t x-axis. Defaults to 90.
        """
        super().__init__(Jr, **kwargs)
        self.width = width
        self.height = height

        self.a = width / 2
        self.b = height / 2

        self.phi = kwargs.pop("phi", 90)
        self.phi_rad = _np.deg2rad(self.phi)

        self.Jx = _np.around(Jr * _np.cos(self.phi_rad), decimals=6)
        self.Jy = _np.around(Jr * _np.sin(self.phi_rad), decimals=6)
        self.tol = MAG_TOL  # sufficient for 0.01 degree accuracy

    def get_size(self):
        """Returns magnet dimesions

        Returns:
            ndarray: numpy array [width, height]
        """
        return _np.array([self.width, self.height])

    def __str__(self):
        str = (
            f"{self.__class__.mag_type}\n"
            + f"J: {self.get_Jr()} (T)\n"
            + f"Size: {self.get_size()}\n"
            + f"Center {self.get_center()}\n"
            + f"Orientation: alpha {self.get_orientation()}\n"
        )
        return str

    def __repr__(self):
        str = (
            f"{self.__class__.mag_type}\n"
            + f"J: {self.get_Jr()} (T)\n"
            + f"Size: {self.get_size()}\n"
            + f"Center {self.get_center()}\n"
            + f"Orientation: alpha {self.get_orientation()}\n"
        )
        return str

    def get_Jr(self):
        """Returns Magnetisation vector

        Returns:
            ndarray: [Jx, Jy]
        """
        return _np.array([self.Jx, self.Jy])

    def get_field(self, x, y):
        """Calculates the magnetic field at point(s) x,y due to a rectangular magnet

        Args:
            x (ndarray): x co-ordinates
            y (ndarray): y co-ordinates

        Returns:
            tuple: magnetic field vector Bx (ndarray), By (ndarray)
        """
        from ..utils._routines2D import _get_field_array_shape2, rotate_points_2D

        array_shape = _get_field_array_shape2(x, y)
        Bx, By = _np.zeros(array_shape), _np.zeros(array_shape)

        if _np.fabs(self.alpha_radians) > Magnet2D.tol:
            xi, yi = rotate_points_2D(
                x - self.center[0], y - self.center[1], self.alpha_radians
            )

        # Calculate field due to x-component of magnetisation
        if _np.fabs(self.Jx / self.Jr) > Magnet2D.tol:
            if _np.fabs(self.alpha_radians) > Magnet2D.tol:

                # Calculate fields in local frame
                Btx = self._calcBx_mag_x(xi, yi)
                Bty = self._calcBy_mag_x(xi, yi)

                # Rotate fields to global frame
                Bx, By = rotate_points_2D(Btx, Bty, 2 * PI - self.alpha_radians)

            else:
                Bx = self._calcBx_mag_x(x - self.center[0], y - self.center[1])
                By = self._calcBy_mag_x(x - self.center[0], y - self.center[1])

        # Calculate field due to y-component of magnetisation
        if _np.fabs(self.Jy / self.Jr) > Magnet2D.tol:
            if _np.fabs(self.alpha_radians) > Magnet2D.tol:

                Btx = self._calcBx_mag_y(xi, yi)
                Bty = self._calcBy_mag_y(xi, yi)

                Bxt, Byt = rotate_points_2D(Btx, Bty, 2 * PI - self.alpha_radians)
                Bx += Bxt
                By += Byt
            else:

                Bx += self._calcBx_mag_y(x - self.center[0], y - self.center[1])
                By += self._calcBy_mag_y(x - self.center[0], y - self.center[1])
        return Bx, By

    def _calcBx_mag_x(self, x, y):
        """Bx using 2D Model for rectangular sheets magnetised in x-plane

        Args:
            x (ndarray): x-coordinates
            y (ndarray): y-coordinates

        Returns:
            ndarray: Bx, x component of magnetic field
        """
        a = self.a
        b = self.b
        J = self.Jx
        # Hide the warning for situtations where there is a divide by zero.
        # This returns a NaN in the array, which is ignored for plotting.
        with _np.errstate(divide="ignore", invalid="ignore"):
            return (J / (2 * PI)) * (
                _np.arctan2((2 * a * (b + y)), (x ** 2 - a ** 2 + (y + b) ** 2))
                + _np.arctan2((2 * a * (b - y)), (x ** 2 - a ** 2 + (y - b) ** 2))
            )

    def _calcBy_mag_x(self, x, y):
        """By using 2D Model for rectangular sheets magnetised in x-plane

        Args:
            x (ndarray): x-coordinates
            y (ndarray): y-coordinates

        Returns:
            ndarray: By, x component of magnetic field
        """
        a = self.a
        b = self.b
        J = self.Jx
        # Hide the warning for situtations where there is a divide by zero.
        # This returns a NaN in the array, which is ignored for plotting.
        with _np.errstate(divide="ignore", invalid="ignore"):
            return (-J / (4 * PI)) * (
                _np.log(((x - a) ** 2 + (y - b) ** 2) / ((x + a) ** 2 + (y - b) ** 2))
                - _np.log(((x - a) ** 2 + (y + b) ** 2) / ((x + a) ** 2 + (y + b) ** 2))
            )

    def _calcBx_mag_y(self, x, y):
        """Bx using 2D Model for rectangular sheets magnetised in y-plane

        Args:
            x (ndarray): x-coordinates
            y (ndarray): y-coordinates

        Returns:
            ndarray: Bx, x component of magnetic field
        """
        a = self.a
        b = self.b
        J = self.Jy
        # Hide the warning for situtations where there is a divide by zero.
        # This returns a NaN in the array, which is ignored for plotting.
        with _np.errstate(divide="ignore", invalid="ignore"):
            return (J / (4 * PI)) * (
                _np.log(((x + a) ** 2 + (y - b) ** 2) / ((x + a) ** 2 + (y + b) ** 2))
                - _np.log(((x - a) ** 2 + (y - b) ** 2) / ((x - a) ** 2 + (y + b) ** 2))
            )

    def _calcBy_mag_y(self, x: float, y: float) -> float:
        """Bx using 2D Model for rectangular sheets magnetised in y-plane

        Args:
            x (ndarray): x-coordinates
            y (ndarray): y-coordinates

        Returns:
            ndarray: By, x component of magnetic field
        """
        a = self.a
        b = self.b
        J = self.Jy
        return (J / (2 * PI)) * (
            _np.arctan2((2 * b * (x + a)), ((x + a) ** 2 + y ** 2 - b ** 2))
            - _np.arctan2((2 * b * (x - a)), ((x - a) ** 2 + y ** 2 - b ** 2))
        )

class Square(Rectangle):
    """Square 2D Magnet Class"""

    mag_type = "Square"

    def __init__(self, width=20, Jr=1.0, **kwargs):
        """Init Method

        Args:
            width (float, optional): Square side length. Defaults to 20.0.
            Jr (float, optional): Remnant Magnetisation. Defaults to 1.0.

        Kwargs:
             alpha (float): Magnetisation orientation angle (in degrees). Defaults to 0.
            center (tuple or ndarray): magnet center (x, y). Defaults to (0,0).
            phi (float): Rotation Angle (in degrees) of magnet w.r.t x-axis. Defaults to 90.
        """
        super().__init__(width=width, height=width, Jr=Jr, **kwargs)

class Line(object):
    """Line Class for storing properties of a sheet manget"""

    def __init__(self, length, center, beta, K):
        """Init Method

        Args:
            length (float): side length
            center (ndarray): magnet center (x, y)
            beta (float): Orientation w.r.t. z-axis in degrees
            K (float): Sheet current density in tesla
        """
        self.length = length
        self.center = center
        self.beta = beta
        self.beta_rad = _np.deg2rad(beta)
        self.xc = center[0]
        self.yc = center[1]
        self.K = K
        self.tol = MAG_TOL

    def __str__(self):
        str = (
            f"K: {self.K} (T)\n"
            + f"Length: {self.length} (m)\n"
            + f"Center {self.center} (m)\n"
            + f"Orientation: {self.beta}\n"
        )
        return str

    def __repr__(self):
        str = (
            f"K: {self.K} (T)\n"
            + f"Length: {self.length}\n"
            + f"Center {self.center}\n"
            + f"Orientation: {self.beta}\n"
        )
        return str

    def get_center(self):
        """Returns line center

        Returns:
            ndarray: center (x,y)
        """

        return self.center

    def get_field(self, x, y):
        """Calculates the magnetic field due to a sheet magnet
        First a transformation into the local coordinates is made, the field calculated
        and then the magnetic field it rotated out to the global coordinates

        Args:
            x (ndarray): x-coordinates
            y (ndarray): y-coordinates

        Returns:
            tuple: Bx (ndarray), By (ndarray) magnetic field vector
        """
        from ..utils._routines2D import _get_field_array_shape2, rotate_points_2D

        array_shape = _get_field_array_shape2(x, y)
        Bx, By = _np.zeros(array_shape), _np.zeros(array_shape)
        if _np.fabs(self.beta_rad) > self.tol:
            xt, yt = rotate_points_2D(x - self.xc, y - self.yc, 2 * PI - self.beta_rad)
            Btx, Bty = _sheet_field(xt, yt, self.length / 2, self.K)
            Bx, By = rotate_points_2D(Btx, Bty, self.beta_rad)

        else:
            Bx, By = _sheet_field(x - self.xc, y - self.yc, self.length / 2, self.K)
        return Bx, By

class LineUtils(object):
    """Utility class consisting of rountines for 2D line elements"""

    @staticmethod
    def unit_norm(vertex_1, vertex_2, clockwise=True):
        """Get unit normal to vertex

        Args:
            vertex_1 (ndarray): vertex 1
            vertex_2 (ndarray): vertex 2
            clockwise (bool, optional): Clockwise orientation of points. Defaults to True.

        Returns:
            tuple: normal vector (ndarray), length i.e. distance between vertices (float)
        """

        dx = vertex_1[0] - vertex_2[0]
        dy = vertex_1[1] - vertex_2[1]

        # Clockwise winding of points:
        if clockwise:
            norm = _np.array([dy, -dx])
        else:
            norm = _np.array([-dy, dx])
        length = _np.linalg.norm(norm)
        norm = norm / length
        return norm, length

    @staticmethod
    def line_center(vertex_1, vertex_2):
        """Gets midpoint of two vertices

        Args:
            vertex_1 (ndarray): vertex 1
            vertex_2 (ndarray): vertex 2

        Returns:
            ndarray: midpoint
        """
        xc = (vertex_1[0] + vertex_2[0]) / 2
        yc = (vertex_1[1] + vertex_2[1]) / 2

        return _np.array([xc, yc])

    @staticmethod
    def signed_area2D(polygon):
        """Calculates signed area of a polygon

        Args:
            polygon (Polygon): Polygon instance

        Returns:
            float: signed area
        """
        j = 1
        NP = polygon.num_vertices()
        area = 0
        norm = _np.empty([NP, 2])
        center = _np.empty([NP, 2])
        beta = _np.empty(NP)  # angle w.r.t. y axis
        length = _np.empty(NP)

        for i in range(NP):
            j = j % NP
            area += (polygon.vertices[j][0] - polygon.vertices[i][0]) * (
                polygon.vertices[j][1] + polygon.vertices[i][1]
            )
            norm[i, :], length[i] = LineUtils.unit_norm(
                polygon.vertices[i], polygon.vertices[j]
            )
            center[i, :] = LineUtils.line_center(
                polygon.vertices[i], polygon.vertices[j]
            )
            j += 1

        # check winding order of polygon, area < 0 for clockwise ordering of points
        if area < 0:
            norm *= -1
        beta[:] = _np.rad2deg(_np.arctan2(norm[:, 1], norm[:, 0]))

        return area / 2.0, norm, beta, length, center

class PolyMagnet(Magnet2D):
    """2D Magnet Polygon class."""

    mag_type = "PolyMagnet"

    def __init__(self, Jr, **kwargs) -> None:
        """Init method

        NOTE:
            * When creating a regular polygon, one of apothem, radius, or length must be defined as a kwarg or an exception will be raised.
            * When creating a regular polygon, the number of sides `num_sides` must be at least 3 or an exception will be raised.
            * When creating a custom polygon at least one vertex pair must be defined with `vertices` or an exception will be raised.

        Args:
            Jr (float): signed magnitude of remnant magnetisation

        Kwargs:
            alpha (float): Not used
            theta (float): Orientation of magnet w.r.t x-axis of magnet
            phi (float): Orientation of magnetisation w.r.t x-axis of magnet in degrees. Defaults to 90.0.
            center (ndarray): magnet center (x, y). Defaults to (0.0, 0.0)
            length (float): side length if creating a regular polygon
            apothem (float): apothem (incircle radius) if creating a regular polygon
            radius (float): radius (circumcircle radius) if  creating a regular polygon
            num_sides (int): number of sides of a regular polygon. Defaults to 6.
            custom_polygon (bool): Flag to define a custom polygon. Defaults to False.
            vertices (ndarray, list): List of custom vertices. Defaults to None.

        Raises:
            Exception: If creating a custom polygon, `vertices` must not be None.
        """
        from ..utils._routines2D import rotate_points_2D

        super().__init__(Jr, **kwargs)

        # Magnet rotation w.r.t. x-axis
        self.alpha = kwargs.pop("alpha", 0.0)
        self.alpha_radians = _np.deg2rad(self.alpha)

        self.theta = kwargs.pop("theta", 0.0)
        self.theta_radians = _np.deg2rad(self.theta)

        self.phi = kwargs.pop("phi", 90.0)
        self.phi_rad = _np.deg2rad(self.phi)

        self.Jx = _np.around(Jr * _np.cos(self.phi_rad), decimals=6)
        self.Jy = _np.around(Jr * _np.sin(self.phi_rad), decimals=6)
        self.tol = MAG_TOL
        self.area = None

        self.custom_polygon = kwargs.pop("custom_polygon", False)

        self.center = kwargs.pop("center", _np.array([0.0, 0.0, 0.0]))
        self.center = _np.asarray(self.center)

        if self.custom_polygon:
            vertices = kwargs.pop("vertices", None)
            if vertices is None:
                raise Exception("Error, no vertices were defined.")

            vertices = _np.atleast_2d(vertices)

            x_rot, y_rot = rotate_points_2D(
                vertices[:, 0],
                vertices[:, 1],
                self.theta_radians,  # + self.alpha_radians,
            )
            vertices = _np.stack([x_rot, y_rot]).T + self.center
            self.polygon = Polygon(vertices=vertices.tolist())
        else:
            self.length = kwargs.pop("length", None)
            self.apothem = kwargs.pop("apothem", None)
            self.radius = kwargs.pop("radius", None)
            self.num_sides = kwargs.pop("num_sides", 6)

            self.radius = Polygon.check_radius(
                self.num_sides,
                self.apothem,
                self.length,
                self.radius,
            )
            # Generate Polygon
            self.polygon = Polygon(
                vertices=Polygon.gen_polygon(
                    self.num_sides,
                    self.center,
                    self.theta,  # + self.alpha,
                    length=self.length,
                    apothem=self.apothem,
                    radius=self.radius,
                ),
                center=self.center,
            )

    def get_center(self):
        """Returns magnet centre

        Returns:
            center (ndarray): numpy array [xc, yc]
        """
        return self.center

    def get_orientation(self):
        """Returns magnet orientation, `alpha` in degrees

        Returns:
            float: alpha, rotation angle w.r.t x-axis.
        """

        return self.alpha

    def _gen_sheet_magnets(self):
        """Generates orientation, size, and centre of sheet magnets for a given
        polygon

        Returns:
            tuple: beta (ndarray), length (ndarray), centre (ndarray), K (ndarray) - sheet current density in tesla.
        """
        area, norms, beta, length, center = LineUtils.signed_area2D(self.polygon)
        K = self.Jx * norms[:, 1] - self.Jy * norms[:, 0]
        self.area = area
        return beta, length, center, K

    def get_field(self, x, y):
        """Calculates the magnetic field of a polygon due to each face

        Args:
            x (ndarray): x-coordinates
            y (ndarray): y-coordinates

        Returns:
            tuple: Bx (ndarray), By (ndarray) magnetic field vector
        """
        from ..utils._routines2D import _get_field_array_shape2

        array_shape = _get_field_array_shape2(x, y)
        Bx, By = _np.zeros(array_shape), _np.zeros(array_shape)
        beta, length, center, K = self._gen_sheet_magnets()

        if _np.fabs(self.alpha_radians) > self.tol:
            pass
            print("Arbitrary rotation with alpha not yet implemented!!")

            # FIXME: rotate centres
            # xt, yt = rotate_points_2D(x - self.xc, y - self.yc, self.alpha_radians)
            # beta += self.alpha
            # xc_rot, yc_rot = rotate_points_2D(
            #     center[:, 0] - self.xc,
            #     center[:, 1] - self.yc,
            #     self.alpha_radians,
            # )
            # center[:, 0] = xc_rot
            # center[:, 1] = yc_rot
            #
            #
            # for i in range(len(K)):
            #     sheet = Line(length[i], center[i], beta[i], K[i])
            #     Btx, Bty = sheet.get_field(xt, yt)
            #     Btx, Bty = rotate_points_2D(Btx, Bty, 2 * PI - self.alpha_radians)
            #     Bx += Btx
            #     By += Bty

        for i in range(len(K)):
            sheet = Line(length[i], center[i], beta[i], K[i])
            Btx, Bty = sheet.get_field(x, y)
            Bx += Btx
            By += Bty
        return Bx, By