moirepy 0.0.1__tar.gz

moirepy-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Aritra Mukhopadhyay, Jabed Umar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

moirepy-0.0.1/MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE
+include README.md
+include requirements.txt

moirepy-0.0.1/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.2
+Name: moirepy
+Version: 0.0.1
+Summary: Simulate moire lattice systems in both real and momentum space and calculate various related observables.
+Home-page: https://github.com/jabed-umar/MoirePy
+Author: Aritra Mukhopadhyay, Jabed Umar
+Author-email: amukherjeeniser@gmail.com, jabedumar12@gmail.com
+Keywords: python,moire,lattice,physics,materials,condensed matter
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Education
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: tqdm
+Requires-Dist: notebook
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: requires-dist
+Dynamic: summary
+
+# MoirePy: Twist It, Solve It, Own It!
+
+MoirePy is a Python package for the analysis of moiré lattice. It is designed to be a user-friendly tool for studying bilayer moiré lattices.
+
+
+<!-- @jabed write here, the license should go at the bottom (I will write within this week)-->
+
+
+
+## License
+
+This project is licensed under the [MIT License](https://opensource.org/licenses/MIT).
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+
+
+## Cite This Work
+
+If you use this software or a modified version in academic or scientific research, please cite:
+
+```BibTeX
+@misc{MoirePy2025,
+	author = {Aritra Mukhopadhyay, Jabed Umar},
+	title = {MoirePy: Python package for efficient tight binding simulation of bilayer moiré lattices},
+	year = {2025},
+	url = {https://jabed-umar.github.io/MoirePy/},
+}
+```

moirepy-0.0.1/README.md

@@ -0,0 +1,29 @@
+# MoirePy: Twist It, Solve It, Own It!
+
+MoirePy is a Python package for the analysis of moiré lattice. It is designed to be a user-friendly tool for studying bilayer moiré lattices.
+
+
+<!-- @jabed write here, the license should go at the bottom (I will write within this week)-->
+
+
+
+## License
+
+This project is licensed under the [MIT License](https://opensource.org/licenses/MIT).
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+
+
+## Cite This Work
+
+If you use this software or a modified version in academic or scientific research, please cite:
+
+```BibTeX
+@misc{MoirePy2025,
+	author = {Aritra Mukhopadhyay, Jabed Umar},
+	title = {MoirePy: Python package for efficient tight binding simulation of bilayer moiré lattices},
+	year = {2025},
+	url = {https://jabed-umar.github.io/MoirePy/},
+}
+```

moirepy-0.0.1/moirepy/__init__.py

@@ -0,0 +1,7 @@
+from moire import MoireLattice
+from layers import (
+    Layer,
+    SquareLayer,
+    TriangularLayer,
+    Rhombus60Layer,
+)

moirepy-0.0.1/moirepy/layers.py

@@ -0,0 +1,577 @@
+import numpy as np
+from typing import List, Tuple
+import matplotlib.pyplot as plt
+import math
+
+from utils import get_rotation_matrix
+
+from scipy.spatial import KDTree
+
+
+# - Lattice vectors must have a +ve y component (both of them need to be in the first or second quadrant)
+# - lv1 must be along the x-axis (i.e. have y = 0)
+# - accordingly lv2 must be writen
+# - If lv2 should not have a negative y component... however if it is desired to have a negative y component, that case is similar to having an lv2 which is
+#     180 degrees rotated (diagonally opposite, -lv2) which has a +ve y component and should be used instead
+
+
+class Layer:  # parent class
+    def __init__(self, pbc=False, study_proximity = 1) -> None:
+        self.toll_scale = max(
+            np.linalg.norm(self.lv1),
+            np.linalg.norm(self.lv2)
+        )
+
+        if self.lv1[1] != 0 or self.lv2[1] < 0:
+            raise ValueError(
+                """lv1 was expected to be along the x-axis, and lv2 should have a +ve y component
+                Please refer to the documentation for more information: https://example.com
+                """  # @jabed add link to documentation
+            )
+
+        self.rot_m = np.eye(2)
+        self.pbc = pbc
+        self.points = None
+        self.kdtree = None
+        self.study_proximity = study_proximity
+
+    def perform_rotation(self, rot=None) -> None:
+        rot_m = get_rotation_matrix(rot)
+        self.rot_m = rot_m
+
+        # Rotate lv1 and lv2 vectors
+        self.lv1 = rot_m @ self.lv1
+        self.lv2 = rot_m @ self.lv2
+
+        # Rotate lattice_points
+        self.lattice_points = [
+            [*(rot_m @ np.array([x, y])), atom_type]
+            for x, y, atom_type in self.lattice_points
+        ]
+
+        # Rotate neighbours
+        self.neighbours = {
+            atom_type: [rot_m @ np.array(neighbour) for neighbour in neighbour_list]
+            for atom_type, neighbour_list in self.neighbours.items()
+        }
+
+    def generate_points(
+            self,
+            mlv1: np.array,
+            mlv2: np.array,
+            mln1: int=1,
+            mln2: int=1,
+            # bring_to_center=False
+        ) -> None:
+        self.mlv1 = mlv1  # Moire lattice vector 1
+        self.mlv2 = mlv2  # Moire lattice vector 2
+        self.mln1 = mln1  # Number of moire unit cells along mlv1
+        self.mln2 = mln2  # Number of moire unit cells along mlv2
+
+        # Step 1: Find the maximum distance to determine the grid resolution
+        points = [np.array([0, 0]), mlv1, mlv2, mlv1 + mlv2]
+        max_distance = max(
+            np.linalg.norm(points[0] - points[1]),
+            np.linalg.norm(points[0] - points[2]),
+            np.linalg.norm(points[0] - points[3]),
+        )
+
+        # Calculate number of grid points based on maximum distance and lattice vectors
+        n = math.ceil(max_distance / min(np.linalg.norm(self.lv1), np.linalg.norm(self.lv2))) * 2
+
+        # print(f"Calculated grid size: {n}")
+
+        # Step 2: Generate points inside one moire unit cell (based on `lv1` and `lv2`)
+        step1_points = []  # List to hold points inside the unit cell
+        step1_names = []  # List to hold the names of the points
+        for i in range(-n, n+1):  # Iterate along mlv1
+            for j in range(-n, n+1):  # Iterate along mlv2
+                # Calculate the lattice point inside the unit cell
+                point_o = i * self.lv1 + j * self.lv2
+                for xpos, ypos, name in self.lattice_points:
+                    point = point_o + np.array([xpos, ypos])
+                    step1_points.append(point)
+                    step1_names.append(name)
+
+        step1_points = np.array(step1_points)
+        step1_names = np.array(step1_names)
+
+        # Apply the boundary check method (_inside_boundaries) to filter the points
+        mask = self._inside_boundaries(step1_points, 1, 1)
+        step1_points = step1_points[mask]
+        step1_names = step1_names[mask]
+
+        # Step 3: Copy and translate the unit cell to create the full moire pattern
+        points = []  # List to hold all the moire points
+        names = []
+        for i in range(self.mln1):  # Translate along mlv1 direction
+            for j in range(self.mln2):  # Translate along mlv2 direction
+                translation_vector = i * mlv1 + j * mlv2
+                translated_points = step1_points + translation_vector  # Translate points
+                points.append(translated_points)
+                names.append(step1_names)
+
+        self.points = np.vstack(points)
+        self.point_types = np.hstack(names)
+        # print(f"{self.point_types.shape=}, {self.points.shape=}")
+        self.generate_kdtree()
+
+    def _point_positions(self, points: np.ndarray, A: np.ndarray, B: np.ndarray) -> np.ndarray:
+        # for each point this returns it's position corresponding to the parallelogram of interest
+        # - if the point is inside, returns (0, 0)
+        # - for outside, left side and right side will give -1 and 1 respectively
+        # - for outside, top side and bottom side will give -1 and 1 respectively
+
+        # Compute determinants for positions relative to OA and BC
+        det_OA = (points[:, 0] * A[1] - points[:, 1] * A[0]) <= self.toll_scale * 1e-2
+        det_BC = ((points[:, 0] - B[0]) * A[1] - (points[:, 1] - B[1]) * A[0]) <= self.toll_scale * 1e-2
+        position_y = det_OA.astype(float) + det_BC.astype(float)
+
+        # Compute determinants for positions relative to OB and AC
+        det_OB = (points[:, 0] * B[1] - points[:, 1] * B[0]) > -self.toll_scale * 1e-2
+        det_AC = ((points[:, 0] - A[0]) * B[1] - (points[:, 1] - A[1]) * B[0]) > -self.toll_scale * 1e-2
+        position_x = det_OB.astype(float) + det_AC.astype(float)
+
+        return np.column_stack((position_x, position_y)) - 1
+
+    def _inside_polygon(self, points: np.ndarray, polygon: np.ndarray) -> np.ndarray:
+        # find the points inside the polygon using the ray casting method
+        x, y = points[:, 0], points[:, 1]
+        px, py = polygon[:, 0], polygon[:, 1]
+        px_next, py_next = np.roll(px, -1), np.roll(py, -1)
+        edge_cond = (y[:, None] > np.minimum(py, py_next)) & (y[:, None] <= np.maximum(py, py_next))
+        with np.errstate(divide='ignore', invalid='ignore'):
+            xinters = np.where(py != py_next, (y[:, None] - py) * (px_next - px) / (py_next - py) + px, np.inf)
+        ray_crosses = edge_cond & (x[:, None] <= xinters)
+        inside = np.sum(ray_crosses, axis=1) % 2 == 1
+        return inside  # mask
+
+    def _inside_boundaries(self, points: np.ndarray, mln1=None, mln2=None) -> np.ndarray:
+
+        v1 = (mln1 if mln1 else self.mln1) * self.mlv1
+        v2 = (mln2 if mln2 else self.mln2) * self.mlv2
+
+        p1 = np.array([0, 0])
+        p2 = np.array([v1[0], v1[1]])
+        p3 = np.array([v2[0], v2[1]])
+        p4 = np.array([v1[0] + v2[0], v1[1] + v2[1]])
+
+        return self._inside_polygon(
+            points,
+            np.array([p1, p2, p4, p3]) - self.toll_scale * 1e-4
+        )
+
+    def generate_kdtree(self) -> None:
+        if not self.pbc:  # OBC is easy
+            self.kdtree = KDTree(self.points)
+            return
+
+        # in case of periodic boundary conditions, we need to generate a bigger set of points
+        all_points = []
+        all_point_names = []
+        for i in range(-1, 2):
+            for j in range(-1, 2):
+                all_points.append(self.points + i * self.mln1 * self.mlv1 + j * self.mln2 * self.mlv2)
+                all_point_names.append(self.point_types)
+
+        all_points = np.vstack(all_points)
+        all_point_names = np.hstack(all_point_names)
+
+        v1 = self.mln1 * self.mlv1
+        v2 = self.mln2 * self.mlv2
+
+        neigh_pad_1 = (1 + self.study_proximity) * np.linalg.norm(self.lv1) / np.linalg.norm(v1)
+        neigh_pad_2 = (1 + self.study_proximity) * np.linalg.norm(self.lv2) / np.linalg.norm(v2)
+
+        mask = self._inside_polygon(all_points, np.array([
+                ( -neigh_pad_1) * v1 + ( -neigh_pad_2) * v2,
+                (1+neigh_pad_1) * v1 + ( -neigh_pad_2) * v2,
+                (1+neigh_pad_1) * v1 + (1+neigh_pad_2) * v2,
+                ( -neigh_pad_1) * v1 + (1+neigh_pad_2) * v2,
+            ])
+        )
+        print(mask.shape, mask.dtype)
+        points = all_points[mask]
+        point_names = all_point_names[mask]
+
+        self.bigger_points = points
+        self.bigger_point_types = point_names
+
+
+        self.kdtree = KDTree(points)
+
+
+
+
+        # # plot the points but with colours based on the point_positions
+        # # - point_positions = [0, 0] -> black
+        # # - point_positions = [1, 0] -> red
+        # # - do not plot the rest of the points at all
+
+        # plt.plot(points[point_positions[:, 0] == 0][:, 0], points[point_positions[:, 0] == 0][:, 1], 'k.')
+        # plt.plot(points[point_positions[:, 0] == 1][:, 0], points[point_positions[:, 0] == 1][:, 1], 'r.')
+
+        # plt.plot(*all_points.T, "ro")
+        # plt.plot(*points.T, "b.")
+
+        # # parallellogram around the whole lattice
+        # plt.plot([0, self.mln1*self.mlv1[0]], [0, self.mln1*self.mlv1[1]], 'k', linewidth=1)
+        # plt.plot([0, self.mln2*self.mlv2[0]], [0, self.mln2*self.mlv2[1]], 'k', linewidth=1)
+        # plt.plot([self.mln1*self.mlv1[0], self.mln1*self.mlv1[0] + self.mln2*self.mlv2[0]], [self.mln1*self.mlv1[1], self.mln1*self.mlv1[1] + self.mln2*self.mlv2[1]], 'k', linewidth=1)
+        # plt.plot([self.mln2*self.mlv2[0], self.mln1*self.mlv1[0] + self.mln2*self.mlv2[0]], [self.mln2*self.mlv2[1], self.mln1*self.mlv1[1] + self.mln2*self.mlv2[1]], 'k', linewidth=1)
+
+        # # just plot mlv1 and mlv2 parallellogram
+        # plt.plot([0, self.mlv1[0]], [0, self.mlv1[1]], 'k', linewidth=1)
+        # plt.plot([0, self.mlv2[0]], [0, self.mlv2[1]], 'k', linewidth=1)
+        # plt.plot([self.mlv1[0], self.mlv1[0] + self.mlv2[0]], [self.mlv1[1], self.mlv1[1] + self.mlv2[1]], 'k', linewidth=1)
+        # plt.plot([self.mlv2[0], self.mlv1[0] + self.mlv2[0]], [self.mlv2[1], self.mlv1[1] + self.mlv2[1]], 'k', linewidth=1)
+
+        # plt.grid()
+        # plt.show()
+
+        self._generate_mapping()
+
+    def _generate_mapping(self) -> None:
+        self.mappings = {}
+        tree = KDTree(self.points)
+        translations = self._point_positions(
+            self.bigger_points,
+            self.mln1 * self.mlv1,
+            self.mln2 * self.mlv2
+        )
+
+
+        for i, (dx, dy) in enumerate(translations):
+            point = self.bigger_points[i] - (dx * self.mlv1 * self.mln1 + dy * self.mlv2 * self.mln2)
+            distance, index = tree.query(point)
+            if distance >= self.toll_scale * 1e-3:
+                print(f"Distance {distance} exceeds tolerance for point {i} at location {point} with translation ({dx}, {dy}).")
+
+
+                plt.plot(*self.bigger_points.T, "ko", alpha=0.3)
+                plt.plot(*self.points.T, "k.")
+
+
+
+                # plt.plot(*self.bigger_points[i], "b.")
+                # plt.plot(*point, "r.")
+                # plt.plot(*self.points[index], "g.")
+
+
+                # parallellogram around the whole lattice
+                plt.plot([0, self.mln1*self.mlv1[0]], [0, self.mln1*self.mlv1[1]], 'k', linewidth=1)
+                plt.plot([0, self.mln2*self.mlv2[0]], [0, self.mln2*self.mlv2[1]], 'k', linewidth=1)
+                plt.plot([self.mln1*self.mlv1[0], self.mln1*self.mlv1[0] + self.mln2*self.mlv2[0]], [self.mln1*self.mlv1[1], self.mln1*self.mlv1[1] + self.mln2*self.mlv2[1]], 'k', linewidth=1)
+                plt.plot([self.mln2*self.mlv2[0], self.mln1*self.mlv1[0] + self.mln2*self.mlv2[0]], [self.mln2*self.mlv2[1], self.mln1*self.mlv1[1] + self.mln2*self.mlv2[1]], 'k', linewidth=1)
+
+                # just plot mlv1 and mlv2 parallellogram
+                plt.plot([0, self.mlv1[0]], [0, self.mlv1[1]], 'k', linewidth=1)
+                plt.plot([0, self.mlv2[0]], [0, self.mlv2[1]], 'k', linewidth=1)
+                plt.plot([self.mlv1[0], self.mlv1[0] + self.mlv2[0]], [self.mlv1[1], self.mlv1[1] + self.mlv2[1]], 'k', linewidth=1)
+                plt.plot([self.mlv2[0], self.mlv1[0] + self.mlv2[0]], [self.            mlv2[1], self.mlv1[1] + self.mlv2[1]], 'k', linewidth=1)
+                # for index, point in enumerate(self.bigger_points):
+                #     plt.text(*point, f"{index}", fontsize=6)
+                plt.gca().add_patch(plt.Circle(point, distance/2, color='r', fill=False))
+
+                plt.grid()
+                plt.show()
+
+                raise ValueError(f"FATAL ERROR: Distance {distance} exceeds tolerance for point {i} at location {point}.")
+            self.mappings[i] = index
+
+        # point positions... for each point in self.point, point position is a array of length 2 (x, y)
+        # where the elemnts are -1, 0 and 1... this is what their value mean about their position
+        # 
+        # (-1, 1) | (0, 1) | (1, 1)
+        # -----------------------------
+        # (-1, 0) | (0, 0) | (1, 0)
+        # -----------------------------
+        # (-1,-1) | (0,-1) | (1,-1)
+        # 
+        # (0, 0) is our actual lattice part... 
+        # do this for all points in self.bigger_points:
+        # all point with point_positions = (x, y) need to be translated by
+        # (-x*self.mlv1*self.mln1 - y*self.mlv2*self.mln2) to get the corresponding point inside the lattice
+        # then you would need to run a query on a newly kdtree of the smaller points...
+        # to the get the index of the corresponding point inside the lattice (distance should be zero, just saying)
+        # now we already know the index of the point in the self.bigger_points... so we can map that to the index of the point in the self.points
+        # then we will store that in `self.mappings``
+        # self.mapppings will be a dictionary with keys as the indices in the
+        # self.bigger_points (unique) and values as the indices in the self.points (not unique)
+
+
+    # def kth_nearest_neighbours(self, points, types, k = 1) -> None:
+    #     distance_matrix = self.kdtree.sparse_distance_matrix(self.kdtree, k)
+
+
+    def first_nearest_neighbours(self, points: np.ndarray, types: np.ndarray):
+        assert self.kdtree is not None, "Generate the KDTree first by calling `Layer.generate_kdtree()`."
+        assert points.shape[0] == types.shape[0], "Mismatch between number of points and types."
+
+        distances_list, indices_list = [], []
+
+        for point, t in zip(points, types):
+            if t not in self.neighbours:
+                raise ValueError(f"Point type '{t}' is not defined in self.neighbours.")
+
+            relative_neighbours = np.array(self.neighbours[t])
+            absolute_neighbours = point + relative_neighbours
+            distances, indices = self.kdtree.query(absolute_neighbours, k=1)
+
+            filtered_distances, filtered_indices = [], []
+            for dist, idx in zip(distances, indices):
+                if self.pbc:
+                    if dist > 1e-2 * self.toll_scale:
+                        raise ValueError(f"Distance {dist} exceeds tolerance.")
+                    filtered_distances.append(dist)
+                    filtered_indices.append(self.mappings[idx])
+                else:
+                    # if dist > 1e-2 * self.toll_scale:
+                    #     raise ValueError(f"Distance {dist} exceeds tolerance.")
+                    filtered_distances.append(dist)
+                    filtered_indices.append(idx)
+
+            distances_list.append(filtered_distances)
+            indices_list.append(filtered_indices)
+
+        return distances_list, indices_list
+
+
+    def query(self, points: np.ndarray, k: int = 1) -> Tuple[np.ndarray, np.ndarray]:
+        # Step 1:
+        # - get a normal query from KDTree
+        # - distance, index = self.kdtree.query(points, k=k)
+        # - remove all the points farther than (1+0.1*toll_scale) * min distance
+        # - return here just that if OBC
+
+        # Step 2: it will come here if PBC is True
+        # - for all the points map them using self.mappings
+        # - replace the indices with the mapped indices
+        # - return the mapped indices and distances (distance will be the same)
+
+        assert self.kdtree is not None, "Generate the KDTree first by calling `Layer.generate_kdtree()`."
+        distances, indices = self.kdtree.query(points, k=k)
+
+        # for k=1, it returns squeezed arrays... so we need to unsqueeze them
+        if k == 1:
+            distances = distances[:, None]
+            indices = indices[:, None]
+
+        distances_list, indices_list = distances.tolist(), indices.tolist()
+        if k > 1:
+            # Set minimum distance threshold
+            min_distance = distances[:, 1].min()
+            threshold = (1 + 1e-2 * self.toll_scale) * min_distance
+            # print(f"{min_distance = }, {threshold = }")
+
+            # Filter distances and indices based on thresholds
+            for i in range(len(distances_list)):
+                while distances_list[i] and distances_list[i][-1] > threshold:
+                    distances_list[i].pop()
+                    indices_list[i].pop()
+
+        if not self.pbc:
+            return distances_list, indices_list
+
+
+        # Convert lists back to numpy arrays for PBC
+        try:
+            distances = np.array(distances_list)
+            indices = np.array(indices_list)
+        except ValueError as e:
+            raise RuntimeError("FATAL ERROR: Uneven row lengths in PBC.") from e
+
+        # Apply mappings
+        try:
+            vectorized_fn = np.vectorize(self.mappings.get)
+            remapped_indices = vectorized_fn(indices)
+        except TypeError as e:
+            raise RuntimeError("FATAL ERROR: Mapping failed during vectorization. Check if all indices are valid.") from e
+        return distances, remapped_indices
+
+    def query_non_self(self, points: np.ndarray, k: int = 1) -> Tuple[np.ndarray, np.ndarray]:
+        distances, indices = self.query(points, k=k+1)
+
+        if self.pbc is False:
+            for i in range(len(indices)):
+                indices[i] = indices[i][1:]
+                distances[i] = distances[i][1:]
+        else:
+            indices = indices[:, 1:]
+            distances = distances[:, 1:]
+
+        # return distances[:, 1:], indices[:, 1:]
+        return distances, indices
+
+
+    def plot_lattice(self, plot_connections: bool = True, plot_unit_cell: bool = False) -> None:
+        # plt.figure(figsize=(8, 8))
+
+        for atom_type, atom_points in self.lattice_points.items():
+            x_coords = [point[0] for point in atom_points]
+            y_coords = [point[1] for point in atom_points]
+            plt.scatter(x_coords, y_coords, s=50)
+
+            if plot_connections:
+                for point in atom_points:
+                    for neighbor in self.neighbours[atom_type]:
+                        connection = point + np.array(neighbor)
+                        plt.plot(
+                            [point[0], connection[0]],
+                            [point[1], connection[1]],
+                            "r--",
+                            alpha=0.5,
+                        )
+
+        if plot_unit_cell:
+            for i in range(self.ny + 1):
+                # line from (lv1*0 + lv2*i) to (lv1*nx + lv2*i)
+                plt.plot(
+                    [self.lv1[0] * 0 + self.lv2[0] * i, self.lv1[0] * self.nx + self.lv2[0] * i],
+                    [self.lv1[1] * 0 + self.lv2[1] * i, self.lv1[1] * self.nx + self.lv2[1] * i],
+                    "k:",
+                    alpha=0.3,
+                )
+
+            for i in range(self.nx + 1):
+                # line from (lv1*i + lv2*0) to (lv1*i + lv2*ny)
+                plt.plot(
+                    [self.lv1[0] * i + self.lv2[0] * 0, self.lv1[0] * i + self.lv2[0] * self.ny],
+                    [self.lv1[1] * i + self.lv2[1] * 0, self.lv1[1] * i + self.lv2[1] * self.ny],
+                    "k:",
+                    alpha=0.3,
+                )
+
+        plt.title("Lattice Points")
+        plt.xlabel("X Coordinate")
+        plt.ylabel("Y Coordinate")
+        plt.axis("equal")
+
+
+
+# ===============================================
+# ========      some example layers      ======== 
+# ===============================================
+
+
+
+class SquareLayer(Layer):
+    def __init__(self, pbc=False) -> None:
+        self.lv1 = np.array([1, 0])  # Lattice vector in the x-direction
+        self.lv2 = np.array([0, 1])  # Lattice vector in the y-direction
+        self.lattice_points = (
+            [0, 0, "A"],
+        )
+        self.neighbours = {
+            "A": [
+                [1, 0],  # Right
+                [0, 1],  # Up
+                [-1, 0], # Left
+                [0, -1], # Down
+            ],
+        }
+        self.study_proximity = 1
+        # study_proximity = 1 means only studying nearest neighbours will be eabled, 2 means study of next nearest neighbours will be enabled too and so on
+        super().__init__(pbc=pbc)  # this has to go at the end
+
+class TriangularLayer(Layer):
+    def __init__(self, pbc=False) -> None:
+        self.lv1 = np.array([1, 0])  # Lattice vector in the x-direction
+        self.lv2 = np.array([0.5, np.sqrt(3)/2])  # Lattice vector at 60 degrees
+        self.lattice_points = (
+            [0, 0, "A"],
+        )
+        self.neighbours = {
+            "A": [
+                [1, 0],  # Right
+                [0.5, np.sqrt(3)/2],  # Right-up
+                [-0.5, np.sqrt(3)/2],  # Left-up
+                [-1, 0],  # Left
+                [-0.5, -np.sqrt(3)/2],  # Left-down
+                [0.5, -np.sqrt(3)/2],  # Right-down
+            ],
+        }
+        self.study_proximity = 1
+        # study_proximity = 1 means only studying nearest neighbours will be eabled, 2 means study of next nearest neighbours will be enabled too and so on
+        super().__init__(pbc=pbc)  # this has to go at the end
+
+class Rhombus60Layer(Layer):
+    def __init__(self, pbc=False) -> None:
+        angle = 60  # hardcoded angle... make a copy of the whole class for different angles
+        self.lv1 = np.array([1, 0])  # Lattice vector in the x-direction
+        cos_angle = np.cos(np.radians(angle))
+        sin_angle = np.sin(np.radians(angle))
+        self.lv2 = np.array([cos_angle, sin_angle])  # Lattice vector at specified angle
+        self.lattice_points = np.array(
+            [0, 0, "A"],
+        )
+        self.neighbours = {
+            "A": [
+                [1, 0],  # Right
+                [cos_angle, sin_angle],  # Up
+                [-1, 0],  # Left
+                [-cos_angle, -sin_angle],  # Down
+            ],
+        }
+        self.study_proximity = 1
+        # study_proximity = 1 means only studying nearest neighbours will be eabled, 2 means study of next nearest neighbours will be enabled too and so on
+        super().__init__(pbc=pbc)  # this has to go at the end
+
+
+# class KagomeLayer(Layer):
+#     def __init__(self, pbc=False) -> None:
+#         self.lv1 = np.array([1, 0])  # Lattice vector in the x-direction
+#         self.lv2 = np.array([0.5, np.sqrt(3)/2])  # Lattice vector at 60 degrees
+
+#         self.lattice_points = (
+#             [0, 0, "A"],
+#             [0.5, 0, "B"],
+#             [0.25, np.sqrt(3)/4, "C"],
+#         )
+
+#         self.neighbours = {
+#             "A": [
+#                 [ 0.5,              0],  # Right
+#                 [ 0.25,  np.sqrt(3)/4],  # Right-up
+#                 [-0.5,              0],  # Left
+#                 [-0.25, -np.sqrt(3)/4],  # Left-down
+#             ],
+#             "B": [
+#                 [ 0.5,              0],  # Right
+#                 [-0.25,  np.sqrt(3)/4],  # Left-up
+#                 [-0.5,              0],  # Left
+#                 [ 0.25, -np.sqrt(3)/4],  # Right-down
+#             ],
+#             "C": [
+#                 [ 0.25,  np.sqrt(3)/4],  # Right-up
+#                 [-0.25,  np.sqrt(3)/4],  # Left-up
+#                 [-0.25, -np.sqrt(3)/4],  # Left-down
+#                 [ 0.25, -np.sqrt(3)/4],  # Right-down
+#             ],
+#         }
+#         super().__init__(pbc=pbc)
+
+
+# class HexagonalLayer(Layer):
+#     def __init__(self, pbc=False) -> None:
+#         self.lv1 = np.array([1, 0]) # Lattice vector in the x-direction
+#         self.lv2 = np.array([0.5, np.sqrt(3) / 2])
+
+#         self.lattice_points = (
+#             # coo_x, coo_y, atom_type (unique)
+#             [0, 0, "A"],
+#             [1, 1/np.sqrt(3), "B"],
+#         )
+#         self.neighbours = {
+#             "A": [
+#                 [0, 1/np.sqrt(3)],
+#                 [-0.5, -1/(2 * np.sqrt(3))],
+#                 [ 0.5, -1/(2 * np.sqrt(3))],
+#             ],
+#             "B": [
+#                 [0.5, 1/(2 * np.sqrt(3))],
+#                 [-0.5, 1/(2 * np.sqrt(3))],
+#                 [0, -1/np.sqrt(3)],
+#             ],
+#         }
+#         super().__init__(pbc=pbc)

moirepy-0.0.1/moirepy/main.py

@@ -0,0 +1,34 @@
+import numpy as np
+
+from layers import (
+    Layer,
+    HexagonalLayer,
+    SquareLayer,
+    TriangularLayer,
+    RhombusLayer,
+    KagomeLayer,
+)
+
+
+class MoireLattice:
+    def __init__(self, layer1: Layer, layer2: Layer, a: int, b: int, m: int, n: int) -> None:
+        self.layer1 = layer1()
+        self.layer2 = layer2()
+        
+        self.mlv1 = a * self.layer1.lv1 + b * self.layer1.lv2
+        self.mlv2 = m * self.layer1.lv1 + n * self.layer1.lv2
+
+        # print(f"{self.mlv1 = }")
+        # print(f"{self.mlv2 = }")
+        # print(f"{m * self.layer2.lv1 + n * self.layer2.lv2}")
+        # print(np.isclose(self.mlv2, m * self.layer2.lv1 + n * self.layer2.lv2))
+        
+        if not np.isclose(self.mlv2, m * self.layer2.lv1 + n * self.layer2.lv2).all():
+            raise ValueError(f"Invalid lattice vectors {a = }, {b = }, {m = }, {n = }. {self.mlv2} != {m * self.layer2.lv1 + n * self.layer2.lv2}")
+
+
+if __name__ == "__main__":
+    layer1 = RhombusLayer
+    layer2 = RhombusLayer
+    
+    lattice = MoireLattice(layer1, layer2, 10, 9, 9, 10)

moirepy-0.0.1/moirepy/moire.py

@@ -0,0 +1,225 @@
+from typing import Union, Callable
+import numpy as np
+from layers import Layer, SquareLayer, Rhombus60Layer, TriangularLayer
+import matplotlib.pyplot as plt
+from utils import get_rotation_matrix
+import time
+
+class MoireLattice:
+    def __init__(self, latticetype: Layer, a:int, b:int, nx:int=1, ny:int=1, interlayer_distance=1, pbc = False):
+        # study_proximity = 1 means only studying nearest neighbours will be eabled, 2 means study of next nearest neighbours will be enabled too and so on
+        lower_lattice = latticetype(pbc=pbc)
+        upper_lattice = latticetype(pbc=pbc)
+
+        lv1, lv2 = lower_lattice.lv1, lower_lattice.lv2
+
+        # c = cos(theta) between lv1 and lv2
+        c = np.dot(lv1, lv2) / (np.linalg.norm(lv1) * np.linalg.norm(lv2))
+        beta = np.arccos(c)
+        mlv1 = lv1 * a + lv2 * b
+        mlv2 = get_rotation_matrix(beta).dot(mlv1)
+        
+        # the actual theta is the angle between a*lv1 + b*lv2 and b*lv1 + a*lv2
+        one = a * lv1 + b * lv2
+        two = b * lv1 + a * lv2
+        c = np.dot(one, two) / (np.linalg.norm(one) * np.linalg.norm(two))
+        theta = np.arccos(c)  # in radians
+        print(f"theta = {theta:.4f} rad ({np.rad2deg(theta):.4f} deg)")
+
+        upper_lattice.perform_rotation(theta)
+
+        lower_lattice.generate_points(mlv1, mlv2, nx, ny)
+        upper_lattice.generate_points(mlv1, mlv2, nx, ny)
+
+        self.a = a
+        self.b = b
+        self.nx = nx
+        self.ny = ny
+        self.lower_lattice = lower_lattice
+        self.upper_lattice = upper_lattice
+        self.theta = theta
+        self.mlv1 = mlv1
+        self.mlv2 = mlv2
+        self.ham = None
+        self.interlayer_distance = interlayer_distance
+
+        print(f"{len(self.lower_lattice.points)} points in lower lattice")
+        print(f"{len(self.upper_lattice.points)} points in upper lattice")
+
+        # self.plot_lattice()
+
+    def plot_lattice(self):
+        mlv1 = self.mlv1
+        mlv2 = self.mlv2
+        nx = self.nx
+        ny = self.ny
+
+        plt.plot(*zip(*self.lower_lattice.points), 'ro')
+        plt.plot(*zip(*self.upper_lattice.points), 'bo')
+
+        # parallellogram around the whole lattice
+        plt.plot([0, nx*mlv1[0]], [0, nx*mlv1[1]], 'k', linewidth=1)
+        plt.plot([0, ny*mlv2[0]], [0, ny*mlv2[1]], 'k', linewidth=1)
+        plt.plot([nx*mlv1[0], nx*mlv1[0] + ny*mlv2[0]], [nx*mlv1[1], nx*mlv1[1] + ny*mlv2[1]], 'k', linewidth=1)
+        plt.plot([ny*mlv2[0], nx*mlv1[0] + ny*mlv2[0]], [ny*mlv2[1], nx*mlv1[1] + ny*mlv2[1]], 'k', linewidth=1)
+
+        # just plot mlv1 and mlv2 parallellogram
+        plt.plot([0, mlv1[0]], [0, mlv1[1]], 'k', linewidth=1)
+        plt.plot([0, mlv2[0]], [0, mlv2[1]], 'k', linewidth=1)
+        plt.plot([mlv1[0], mlv1[0] + mlv2[0]], [mlv1[1], mlv1[1] + mlv2[1]], 'k', linewidth=1)
+        plt.plot([mlv2[0], mlv1[0] + mlv2[0]], [mlv2[1], mlv1[1] + mlv2[1]], 'k', linewidth=1)
+
+        plt.grid()
+        plt.show()
+
+    def _validate_input1(self, a, name):
+        if a is None:
+            a = 1
+            print(f"WARNING: {name} is not set, setting it to 1")
+        if callable(a): return a
+        return lambda this_coo, neigh_coo, this_type, neigh_type: a
+
+    def _validate_input2(self, a, name):
+        if a is None:
+            a = 0
+            print(f"WARNING: {name} is not set, setting it to 1")
+        if callable(a): return a
+        return lambda this_coo, this_type: a
+
+    def generate_hamiltonian(
+        self,
+        tll: Union[float, int, Callable[[float], float]] = None,
+        tuu: Union[float, int, Callable[[float], float]] = None,
+        tlu: Union[float, int, Callable[[float], float]] = None,
+        tul: Union[float, int, Callable[[float], float]] = None,
+        tuself: Union[float, int, Callable[[float], float]] = None,
+        tlself: Union[float, int, Callable[[float], float]] = None,
+    ):
+        if tll is None or isinstance(tll, int) or isinstance(tll, float): tll = self._validate_input1(tll, "tll")
+        if tuu is None or isinstance(tuu, int) or isinstance(tuu, float): tuu = self._validate_input1(tuu, "tuu")
+        if tlu is None or isinstance(tlu, int) or isinstance(tlu, float): tlu = self._validate_input1(tlu, "tlu")
+        if tul is None or isinstance(tul, int) or isinstance(tul, float): tul = self._validate_input1(tul, "tul")
+        if tuself is None or isinstance(tuself, int) or isinstance(tuself, float): tuself = self._validate_input2(tuself, "tuself")
+        if tlself is None or isinstance(tlself, int) or isinstance(tlself, float): tlself = self._validate_input2(tlself, "tlself")
+        assert (
+                callable(tll)
+            and callable(tuu)
+            and callable(tlu)
+            and callable(tul)
+            and callable(tuself)
+            and callable(tlself)
+        ), "tuu, tll, tlu, tul, tuself and tlself must be floats, ints or callable objects like functions"
+        # self.plot_lattice()
+
+        # 1. interaction inside the lower lattice
+        ham_ll = np.zeros((len(self.lower_lattice.points), len(self.lower_lattice.points)))
+        _, indices = self.lower_lattice.first_nearest_neighbours(self.lower_lattice.points, self.lower_lattice.point_types)
+        for i in range(len(self.lower_lattice.points)):  # self interactions
+            ham_ll[i, i] = tlself(
+                self.lower_lattice.points[i],
+                self.lower_lattice.point_types[i]
+            )
+        for this_i in range(len(self.lower_lattice.points)):  # neighbour interactions
+            this_coo = self.lower_lattice.points[this_i]
+            this_type = self.lower_lattice.point_types[this_i]
+            for neigh_i in indices[this_i]:
+                neigh_coo = self.lower_lattice.points[neigh_i]
+                neigh_type = self.lower_lattice.point_types[neigh_i]
+                ham_ll[this_i, neigh_i] = tuu(this_coo, neigh_coo, this_type, neigh_type)
+
+        # 2. interaction inside the upper lattice
+        ham_uu = np.zeros((len(self.upper_lattice.points), len(self.upper_lattice.points)))
+        _, indices = self.upper_lattice.first_nearest_neighbours(self.upper_lattice.points, self.upper_lattice.point_types)
+        for i in range(len(self.upper_lattice.points)):  # self interactions
+            ham_uu[i, i] = tuself(
+                self.upper_lattice.points[i],
+                self.upper_lattice.point_types[i]
+            )
+        for this_i in range(len(self.upper_lattice.points)):  # neighbour interactions
+            this_coo = self.upper_lattice.points[this_i]
+            this_type = self.upper_lattice.point_types[this_i]
+            for neigh_i in indices[this_i]:
+                neigh_coo = self.upper_lattice.points[neigh_i]
+                neigh_type = self.upper_lattice.point_types[neigh_i]
+                ham_uu[this_i, neigh_i] = tll(this_coo, neigh_coo, this_type, neigh_type)
+
+        # 3. interaction from the lower to the upper lattice
+        ham_lu = np.zeros((len(self.lower_lattice.points), len(self.upper_lattice.points)))
+        _, indices = self.upper_lattice.query(self.lower_lattice.points, k=1)
+        for this_i in range(len(self.lower_lattice.points)):
+            neigh_i = indices[this_i]
+            ham_lu[this_i, neigh_i] = tlu(
+                self.lower_lattice.points[this_i],
+                self.upper_lattice.points[neigh_i],
+                self.lower_lattice.point_types[this_i],
+                self.upper_lattice.point_types[neigh_i],
+            )
+
+        # 4. interaction from the upper to the lower lattice
+        ham_ul = np.zeros((len(self.upper_lattice.points), len(self.lower_lattice.points)))
+        _, indices = self.lower_lattice.query(self.upper_lattice.points, k=1)
+        for this_i in range(len(self.upper_lattice.points)):
+            neigh_i = indices[this_i]
+            ham_ul[this_i, neigh_i] = tul(
+                self.upper_lattice.points[this_i],
+                self.lower_lattice.points[neigh_i],
+                self.upper_lattice.point_types[this_i],
+                self.lower_lattice.point_types[neigh_i],
+            )
+
+        # # in ham_ll and ham_uu, check if sum of all the rows...
+        # # for constant t it should represent the number of neighbours for each point
+        # print(f"unique sums in ham_ll: {np.unique(np.sum(ham_ll, axis=1))}")
+        # print(f"unique sums in ham_uu: {np.unique(np.sum(ham_uu, axis=1))}")
+        # print(f"unique sums in ham_lu: {np.unique(np.sum(ham_lu, axis=1))}")
+        # print(f"unique sums in ham_ul: {np.unique(np.sum(ham_ul, axis=1))}")
+
+        # combine the hamiltonians
+        self.ham = np.block([
+            [ham_ll, ham_lu],
+            [ham_ul, ham_uu]
+        ])
+
+
+        return self.ham
+
+
+
+
+
+if __name__ == "__main__":
+
+    t = time.time()
+
+    # lattice = MoireLattice(TriangularLayer, 9, 10, 3+0, 2+0, pbc=False)
+    # lattice = MoireLattice(TriangularLayer, 5, 6, 2, 2, pbc=True)
+    lattice = MoireLattice(SquareLayer, 6, 7, 2, 2, pbc=True)
+    # lattice = MoireLattice(TriangularLayer, 5, 6, 2, 2, pbc=True)
+    # lattice = MoireLattice(TriangularLayer, 12, 13, 1, 1, pbc=True)
+    # lattice = MoireLattice(TriangularLayer, 9, 10, 2, 4, pbc=False)
+
+    print(f"initialization took: {time.time() - t:.2f} seconds")
+    t = time.time()
+
+    ham = lattice.generate_hamiltonian(1, 1, 1)
+
+    print(f"hamiltonian generation took: {time.time() - t:.2f} seconds")
+
+    # check if ham is hermitian
+    if np.allclose(ham, ham.T.conj()): print("Hamiltonian is hermitian.")
+    else: print("Hamiltonian is not hermitian.")
+
+    t = time.time()
+
+    evals, evecs = np.linalg.eigh(ham)
+
+    print(f"diagonalization took: {time.time() - t:.2f} seconds")
+
+
+
+
+    plt.imshow(ham, cmap="gray")
+    plt.colorbar()
+    plt.show()
+
+    # lattice.plot_lattice()

moirepy-0.0.1/moirepy/utils.py

@@ -0,0 +1,9 @@
+import numpy as np
+
+def get_rotation_matrix(theta_rad):
+    return np.array(
+        [
+            [np.cos(theta_rad), -np.sin(theta_rad)],
+            [np.sin(theta_rad),  np.cos(theta_rad)]
+        ]
+    )

moirepy-0.0.1/moirepy.egg-info/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.2
+Name: moirepy
+Version: 0.0.1
+Summary: Simulate moire lattice systems in both real and momentum space and calculate various related observables.
+Home-page: https://github.com/jabed-umar/MoirePy
+Author: Aritra Mukhopadhyay, Jabed Umar
+Author-email: amukherjeeniser@gmail.com, jabedumar12@gmail.com
+Keywords: python,moire,lattice,physics,materials,condensed matter
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Education
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: tqdm
+Requires-Dist: notebook
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: requires-dist
+Dynamic: summary
+
+# MoirePy: Twist It, Solve It, Own It!
+
+MoirePy is a Python package for the analysis of moiré lattice. It is designed to be a user-friendly tool for studying bilayer moiré lattices.
+
+
+<!-- @jabed write here, the license should go at the bottom (I will write within this week)-->
+
+
+
+## License
+
+This project is licensed under the [MIT License](https://opensource.org/licenses/MIT).
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+
+
+## Cite This Work
+
+If you use this software or a modified version in academic or scientific research, please cite:
+
+```BibTeX
+@misc{MoirePy2025,
+	author = {Aritra Mukhopadhyay, Jabed Umar},
+	title = {MoirePy: Python package for efficient tight binding simulation of bilayer moiré lattices},
+	year = {2025},
+	url = {https://jabed-umar.github.io/MoirePy/},
+}
+```

moirepy-0.0.1/moirepy.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+MANIFEST.in
+README.md
+requirements.txt
+setup.py
+moirepy/__init__.py
+moirepy/layers.py
+moirepy/main.py
+moirepy/moire.py
+moirepy/utils.py
+moirepy.egg-info/PKG-INFO
+moirepy.egg-info/SOURCES.txt
+moirepy.egg-info/dependency_links.txt
+moirepy.egg-info/requires.txt
+moirepy.egg-info/top_level.txt

moirepy-0.0.1/moirepy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

moirepy-0.0.1/moirepy.egg-info/requires.txt

@@ -0,0 +1,5 @@
+numpy
+scipy
+matplotlib
+tqdm
+notebook

moirepy-0.0.1/moirepy.egg-info/top_level.txt

@@ -0,0 +1 @@
+moirepy

moirepy-0.0.1/requirements.txt

@@ -0,0 +1,5 @@
+numpy
+scipy
+matplotlib
+tqdm
+notebook

moirepy-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

moirepy-0.0.1/setup.py

@@ -0,0 +1,43 @@
+from setuptools import setup, find_packages
+
+VERSION = '0.0.1'
+DESCRIPTION = 'Simulate moire lattice systems in both real and momentum space and calculate various related observables.'
+with open("README.md", "r") as f:
+    LONG_DESCRIPTION = f.read()
+with open("requirements.txt", "r") as f:
+    INSTALL_REQUIRES = f.read().splitlines()
+
+# Setting up
+setup(
+    name="moirepy",
+    version=VERSION,
+    author="Aritra Mukhopadhyay, Jabed Umar",
+    author_email="amukherjeeniser@gmail.com, jabedumar12@gmail.com",
+    description=DESCRIPTION,
+    long_description_content_type="text/markdown",
+    long_description=LONG_DESCRIPTION,
+    packages=find_packages(),
+    install_requires=INSTALL_REQUIRES,
+    url="https://github.com/jabed-umar/MoirePy",
+    keywords=['python', 'moire', 'lattice', 'physics', 'materials', 'condensed matter'],
+    classifiers=[
+        "Development Status :: 2 - Pre-Alpha",
+        "Intended Audience :: Education",
+        "Intended Audience :: Science/Research",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Topic :: Education",
+        "Topic :: Scientific/Engineering",
+        "Topic :: Scientific/Engineering :: Chemistry",
+        "Topic :: Scientific/Engineering :: Mathematics",
+        "Topic :: Scientific/Engineering :: Physics",
+    ]
+)