@mat3ra/made 2024.7.1-0 → 2024.7.2-0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mat3ra/made",
-    "version": "2024.7.1-0",
+    "version": "2024.7.2-0",
     "description": "MAterials DEsign library",
     "scripts": {
         "lint": "eslint --cache src/js tests/js && prettier --write src/js tests/js",

package/src/py/mat3ra/made/tools/modify.py

@@ -9,6 +9,7 @@ from .third_party import PymatgenSpacegroupAnalyzer, PymatgenStructure
 from .utils import (
     is_coordinate_in_box,
     is_coordinate_in_cylinder,
+    is_coordinate_in_triangular_prism,
     is_coordinate_within_layer,
     translate_to_bottom_pymatgen_structure,
 )
@@ -241,10 +242,8 @@ def filter_by_cylinder(
 
 def filter_by_rectangle_projection(
     material: Material,
-    x_min: float = 0.0,
-    y_min: float = 0.0,
-    x_max: float = 1.0,
-    y_max: float = 1.0,
+    min_coordinate: List[float] = [0, 0],
+    max_coordinate: List[float] = [1, 1],
     use_cartesian_coordinates: bool = False,
     invert_selection: bool = False,
 ) -> Material:
@@ -252,21 +251,20 @@ def filter_by_rectangle_projection(
     Get material with atoms that are within or outside an XY rectangle projection.
 
     Args:
-
         material (Material): The material object to filter.
-        x_min (float): The minimum x-coordinate of the rectangle.
-        y_min (float): The minimum y-coordinate of the rectangle.
-        x_max (float): The maximum x-coordinate of the rectangle.
-        y_max (float): The maximum y-coordinate of the rectangle.
+        min_coordinate (List[float]): The minimum coordinate of the rectangle.
+        max_coordinate (List[float]): The maximum coordinate of the rectangle.
         use_cartesian_coordinates (bool): Whether to use cartesian coordinates
         invert_selection (bool): Whether to invert the selection.
 
     Returns:
         Material: The filtered material object.
     """
+    min_coordinate = min_coordinate[:2] + [0]
+    max_coordinate = max_coordinate[:2] + [1]
 
     def condition(coordinate):
-        return is_coordinate_in_box(coordinate, [x_min, y_min, 0], [x_max, y_max, 1])
+        return is_coordinate_in_box(coordinate, min_coordinate, max_coordinate)
 
     return filter_by_condition_on_coordinates(
         material, condition, use_cartesian_coordinates=use_cartesian_coordinates, invert_selection=invert_selection
@@ -290,3 +288,38 @@ def filter_by_box(
     return filter_by_condition_on_coordinates(
         material, condition, use_cartesian_coordinates=use_cartesian_coordinates, invert_selection=invert_selection
     )
+
+
+def filter_by_triangle_projection(
+    material: Material,
+    coordinate_1: List[float] = [0, 0],
+    coordinate_2: List[float] = [0, 1],
+    coordinate_3: List[float] = [1, 0],
+    min_z: float = 0,
+    max_z: float = 1,
+    use_cartesian_coordinates: bool = False,
+    invert_selection: bool = False,
+) -> Material:
+    """
+    Get material with atoms that are within or outside a prism formed by triangle projection.
+
+    Args:
+        material (Material): The material object to filter.
+        coordinate_1 (List[float]): The coordinate of the first vertex.
+        coordinate_2 (List[float]): The coordinate of the second vertex.
+        coordinate_3 (List[float]): The coordinate of the third vertex.
+        min_z (float): Lower limit of z-coordinate.
+        max_z (float): Upper limit of z-coordinate.
+        use_cartesian_coordinates (bool): Whether to use cartesian coordinates
+        invert_selection (bool): Whether to invert the selection.
+
+    Returns:
+        Material: The filtered material object.
+    """
+
+    def condition(coordinate):
+        return is_coordinate_in_triangular_prism(coordinate, coordinate_1, coordinate_2, coordinate_3, min_z, max_z)
+
+    return filter_by_condition_on_coordinates(
+        material, condition, use_cartesian_coordinates=use_cartesian_coordinates, invert_selection=invert_selection
+    )

package/src/py/mat3ra/made/tools/utils.py

@@ -105,7 +105,7 @@ def is_coordinate_in_cylinder(
     coordinate: List[float], center_position: List[float], radius: float = 0.25, min_z: float = 0, max_z: float = 1
 ) -> bool:
     """
-    Check if a point is inside a cylinder.
+    Check if a coordinate is inside a cylinder.
     Args:
         coordinate (List[float]): The coordinate to check.
         center_position (List[float]): The coordinates of the center position.
@@ -114,7 +114,7 @@ def is_coordinate_in_cylinder(
         radius (float): The radius of the cylinder.
 
     Returns:
-        bool: True if the point is inside the cylinder, False otherwise.
+        bool: True if the coordinate is inside the cylinder, False otherwise.
     """
     return (coordinate[0] - center_position[0]) ** 2 + (coordinate[1] - center_position[1]) ** 2 <= radius**2 and (
         min_z <= coordinate[2] <= max_z
@@ -125,13 +125,13 @@ def is_coordinate_in_box(
     coordinate: List[float], min_coordinate: List[float] = [0, 0, 0], max_coordinate: List[float] = [1, 1, 1]
 ) -> bool:
     """
-    Check if a point is inside a box.
+    Check if a coordinate is inside a box.
     Args:
         coordinate (List[float]): The coordinate to check.
         min_coordinate (List[float]): The minimum coordinate of the box.
         max_coordinate (List[float]): The maximum coordinate of the box.
     Returns:
-        bool: True if the point is inside the box, False otherwise.
+        bool: True if the coordinate is inside the box, False otherwise.
     """
     x_min, y_min, z_min = min_coordinate
     x_max, y_max, z_max = max_coordinate
@@ -142,7 +142,7 @@ def is_coordinate_within_layer(
     coordinate: List[float], center_position: List[float], direction_vector: List[float], layer_thickness: float
 ) -> bool:
     """
-    Checks if a point's projection along a specified direction vector
+    Checks if a coordinate's projection along a specified direction vector
     is within a certain layer thickness centered around a given position.
 
     Args:
@@ -152,7 +152,7 @@ def is_coordinate_within_layer(
         layer_thickness (float): The thickness of the layer along the direction vector.
 
     Returns:
-        bool: True if the point is within the layer thickness, False otherwise.
+        bool: True if the coordinate is within the layer thickness, False otherwise.
     """
     direction_norm = np.array(direction_vector) / np.linalg.norm(direction_vector)
     central_projection = np.dot(center_position, direction_norm)
@@ -162,3 +162,54 @@ def is_coordinate_within_layer(
     upper_bound = central_projection + layer_thickness_frac / 2
 
     return lower_bound <= np.dot(coordinate, direction_norm) <= upper_bound
+
+
+def is_coordinate_in_triangular_prism(
+    coordinate: List[float],
+    coordinate_1: List[float],
+    coordinate_2: List[float],
+    coordinate_3: List[float],
+    min_z: float = 0,
+    max_z: float = 1,
+) -> bool:
+    """
+    Check if a coordinate is inside a triangular prism.
+    Args:
+        coordinate (List[float]): The coordinate to check.
+        coordinate_1 (List[float]): The first coordinate of the triangle.
+        coordinate_2 (List[float]): The second coordinate of the triangle.
+        coordinate_3 (List[float]): The third coordinate of the triangle.
+        min_z (float): Lower limit of z-coordinate.
+        max_z (float): Upper limit of z-coordinate.
+
+    Returns:
+        bool: True if the coordinate is inside the triangular prism, False otherwise.
+    """
+    # convert to 3D coordinates at the origin XY plane
+    coordinate_1.extend([0] * (3 - len(coordinate_1)))
+    coordinate_2.extend([0] * (3 - len(coordinate_2)))
+    coordinate_3.extend([0] * (3 - len(coordinate_3)))
+
+    coordinate = np.array(coordinate)
+    v1 = np.array(coordinate_1)
+    v2 = np.array(coordinate_2)
+    v3 = np.array(coordinate_3)
+
+    v2_v1 = v2 - v1
+    v3_v1 = v3 - v1
+    coordinate_v1 = coordinate - v1
+
+    # Compute dot products for the barycentric coordinates
+    d00 = np.dot(v2_v1, v2_v1)
+    d01 = np.dot(v2_v1, v3_v1)
+    d11 = np.dot(v3_v1, v3_v1)
+    d20 = np.dot(coordinate_v1, v2_v1)
+    d21 = np.dot(coordinate_v1, v3_v1)
+
+    # Calculate barycentric coordinates
+    denom = d00 * d11 - d01 * d01
+    v = (d11 * d20 - d01 * d21) / denom
+    w = (d00 * d21 - d01 * d20) / denom
+    u = 1.0 - v - w
+
+    return (u >= 0) and (v >= 0) and (w >= 0) and (u + v + w <= 1) and (min_z <= coordinate[2] <= max_z)

package/tests/py/unit/test_tools_modify.py

@@ -7,6 +7,7 @@ from mat3ra.made.tools.modify import (
     filter_by_layers,
     filter_by_rectangle_projection,
     filter_by_sphere,
+    filter_by_triangle_projection,
 )
 from mat3ra.utils import assertion as assertion_utils
 
@@ -126,3 +127,12 @@ def test_filter_by_rectangle_projection():
     # Default will contain all the atoms
     section = filter_by_rectangle_projection(material)
     assertion_utils.assert_deep_almost_equal(material.basis.to_json(), section.basis.to_json())
+
+
+def test_filter_by_triangle_projection():
+    # Small prism in the middle of the cell containing the central atom will be removed -- the same as with sphere
+    material = Material(SI_CONVENTIONAL_CELL)
+    section = filter_by_triangle_projection(material, [0.4, 0.4], [0.4, 0.5], [0.5, 0.5])
+    cavity = filter_by_triangle_projection(material, [0.4, 0.4], [0.4, 0.5], [0.5, 0.5], invert_selection=True)
+    assertion_utils.assert_deep_almost_equal(expected_basis_sphere_cluster, section.basis.to_json())
+    assertion_utils.assert_deep_almost_equal(expected_basis_sphere_cavity, cavity.basis.to_json())