remove outdated interaction plane

Author: skim0119

elastica/__init__.py

@@ -28,8 +28,6 @@
     EndpointForcesSinusoidal,
 )
 from elastica.interaction import (
-    AnisotropicFrictionalPlane,
-    InteractionPlane,
     SlenderBodyTheory,
 )
 from elastica.joint import (

elastica/interaction.py

@@ -9,8 +9,6 @@
     _node_to_element_velocity,
 )
 from elastica._contact_functions import (
-    _calculate_contact_forces_rod_plane,
-    _calculate_contact_forces_rod_plane_with_anisotropic_friction,
     _calculate_contact_forces_cylinder_plane,
 )
 
@@ -19,213 +17,6 @@
 from elastica.typing import SystemType, RodType, RigidBodyType
 
 
-# base class for interaction
-# only applies normal force no friction
-class InteractionPlane(NoForces):
-    """
-    The interaction plane class computes the plane reaction
-    force on a rod-like object.  For more details regarding the contact module refer to
-    Eqn 4.8 of Gazzola et al. RSoS (2018).
-
-        Attributes
-        ----------
-        k: float
-            Stiffness coefficient between the plane and the rod-like object.
-        nu: float
-            Dissipation coefficient between the plane and the rod-like object.
-        plane_origin: numpy.ndarray
-            2D (dim, 1) array containing data with 'float' type.
-            Origin of the plane.
-        plane_normal: numpy.ndarray
-           2D (dim, 1) array containing data with 'float' type.
-           The normal vector of the plane.
-        surface_tol: float
-            Penetration tolerance between the plane and the rod-like object.
-
-    """
-
-    def __init__(
-        self,
-        k: float,
-        nu: float,
-        plane_origin: NDArray[np.float64],
-        plane_normal: NDArray[np.float64],
-    ) -> None:
-        """
-
-        Parameters
-        ----------
-        k: float
-            Stiffness coefficient between the plane and the rod-like object.
-        nu: float
-            Dissipation coefficient between the plane and the rod-like object.
-        plane_origin: numpy.ndarray
-           2D (dim, 1) array containing data with 'float' type.
-           Origin of the plane.
-        plane_normal: numpy.ndarray
-            2D (dim, 1) array containing data with 'float' type.
-            The normal vector of the plane.
-        """
-        self.k = np.float64(k)
-        self.nu = np.float64(nu)
-        self.surface_tol = np.float64(1e-4)
-        self.plane_origin = plane_origin.reshape(3, 1)
-        self.plane_normal = plane_normal.reshape(3)
-
-    def apply_forces(self, system: RodType, time: np.float64 = np.float64(0.0)) -> None:
-        """
-        In the case of contact with the plane, this function computes the plane reaction force on the element.
-
-        Parameters
-        ----------
-        system: object
-            Rod-like object.
-
-        Returns
-        -------
-        plane_response_force_mag : numpy.ndarray
-            1D (blocksize) array containing data with 'float' type.
-            Magnitude of plane response force acting on rod-like object.
-        no_contact_point_idx : numpy.ndarray
-            1D (blocksize) array containing data with 'int' type.
-            Index of rod-like object elements that are not in contact with the plane.
-        """
-        return _calculate_contact_forces_rod_plane(
-            self.plane_origin,
-            self.plane_normal,
-            self.surface_tol,
-            self.k,
-            self.nu,
-            system.radius,
-            system.mass,
-            system.position_collection,
-            system.velocity_collection,
-            system.internal_forces,
-            system.external_forces,
-        )
-
-
-# class for anisotropic frictional plane
-# NOTE: friction coefficients are passed as arrays in the order
-# mu_forward : mu_backward : mu_sideways
-# head is at x[0] and forward means head to tail
-# same convention for kinetic and static
-# mu named as to which direction it opposes
-class AnisotropicFrictionalPlane(InteractionPlane):
-    """
-    This anisotropic friction plane class is for computing
-    anisotropic friction forces on rods.
-    A detailed explanation of the implemented equations
-    can be found in Gazzola et al. RSoS. (2018).
-
-        Attributes
-        ----------
-        k: float
-            Stiffness coefficient between the plane and the rod-like object.
-        nu: float
-            Dissipation coefficient between the plane and the rod-like object.
-        plane_origin: numpy.ndarray
-            2D (dim, 1) array containing data with 'float' type.
-            Origin of the plane.
-        plane_normal: numpy.ndarray
-            2D (dim, 1) array containing data with 'float' type.
-            The normal vector of the plane.
-        slip_velocity_tol: float
-            Velocity tolerance to determine if the element is slipping or not.
-        static_mu_array: numpy.ndarray
-            1D (3,) array containing data with 'float' type.
-            [forward, backward, sideways] static friction coefficients.
-        kinetic_mu_array: numpy.ndarray
-            1D (3,) array containing data with 'float' type.
-            [forward, backward, sideways] kinetic friction coefficients.
-    """
-
-    def __init__(
-        self,
-        k: float,
-        nu: float,
-        plane_origin: NDArray[np.float64],
-        plane_normal: NDArray[np.float64],
-        slip_velocity_tol: float,
-        static_mu_array: NDArray[np.float64],
-        kinetic_mu_array: NDArray[np.float64],
-    ) -> None:
-        """
-
-        Parameters
-        ----------
-        k: float
-            Stiffness coefficient between the plane and the rod-like object.
-        nu: float
-            Dissipation coefficient between the plane and the rod-like object.
-        plane_origin: numpy.ndarray
-            2D (dim, 1) array containing data with 'float' type.
-            Origin of the plane.
-        plane_normal: numpy.ndarray
-            2D (dim, 1) array containing data with 'float' type.
-            The normal vector of the plane.
-        slip_velocity_tol: float
-            Velocity tolerance to determine if the element is slipping or not.
-        static_mu_array: numpy.ndarray
-            1D (3,) array containing data with 'float' type.
-            [forward, backward, sideways] static friction coefficients.
-        kinetic_mu_array: numpy.ndarray
-            1D (3,) array containing data with 'float' type.
-            [forward, backward, sideways] kinetic friction coefficients.
-        """
-        InteractionPlane.__init__(self, k, nu, plane_origin, plane_normal)
-        self.slip_velocity_tol = np.float64(slip_velocity_tol)
-        (
-            self.static_mu_forward,
-            self.static_mu_backward,
-            self.static_mu_sideways,
-        ) = static_mu_array
-        (
-            self.kinetic_mu_forward,
-            self.kinetic_mu_backward,
-            self.kinetic_mu_sideways,
-        ) = kinetic_mu_array
-
-    # kinetic and static friction should separate functions
-    # for now putting them together to figure out common variables
-    def apply_forces(
-        self, system: "RodType | RigidBodyType", time: np.float64 = np.float64(0.0)
-    ) -> None:
-        """
-        Call numba implementation to apply friction forces
-        Parameters
-        ----------
-        system : RodType | RigidBodyType
-        time
-
-        """
-        _calculate_contact_forces_rod_plane_with_anisotropic_friction(
-            self.plane_origin,
-            self.plane_normal,
-            self.surface_tol,
-            self.slip_velocity_tol,
-            self.k,
-            self.nu,
-            self.kinetic_mu_forward,
-            self.kinetic_mu_backward,
-            self.kinetic_mu_sideways,
-            self.static_mu_forward,
-            self.static_mu_backward,
-            self.static_mu_sideways,
-            system.radius,
-            system.mass,
-            system.tangents,
-            system.position_collection,
-            system.director_collection,
-            system.velocity_collection,
-            system.omega_collection,
-            system.internal_forces,
-            system.external_forces,
-            system.internal_torques,
-            system.external_torques,
-        )
-
-
 # Slender body module
 @njit(cache=True)  # type: ignore
 def sum_over_elements(input: NDArray[np.float64]) -> np.float64: