pythonknot 0.1__tar.gz

pythonknot-0.1/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: pythonknot
+Version: 0.1
+Summary: pythonknot for knot theory calculation
+Home-page: 
+Author: yjianzhu
+Author-email: yjianzhu@mail.ustc.edu.cn
+License: UNKNOWN
+Platform: UNKNOWN
+
+Python Knot is a Python package for creating and manipulating knots and links, calculating knot invariants, and more.
+

pythonknot-0.1/README.md

@@ -0,0 +1,13 @@
+# Python Knot package: pythonknot
+
+Python Knot is a Python package for creating and manipulating knots and links. It is based on the [KnotTheory](https://knot.theory.org) package for Mathematica.
+
+## Installation
+
+## Features
+
+1. Create and manipulate knots and links.
+2. Compute invariants of knots and links.
+3. Visualize knots and links.
+
+## Usage

pythonknot-0.1/setup.cfg

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

pythonknot-0.1/setup.py

@@ -0,0 +1,148 @@
+import setuptools
+
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+from setuptools import Extension, setup
+from setuptools.command.build_ext import build_ext
+
+# Convert distutils Windows platform specifiers to CMake -A arguments
+PLAT_TO_CMAKE = {
+    "win32": "Win32",
+    "win-amd64": "x64",
+    "win-arm32": "ARM",
+    "win-arm64": "ARM64",
+}
+
+
+# A CMakeExtension needs a sourcedir instead of a file list.
+# The name must be the _single_ output extension from the CMake build.
+# If you need multiple extensions, see scikit-build.
+class CMakeExtension(Extension):
+    def __init__(self, name: str, sourcedir: str = "") -> None:
+        super().__init__(name, sources=[])
+        self.sourcedir = os.fspath(Path(sourcedir).resolve())
+
+
+class CMakeBuild(build_ext):
+    def build_extension(self, ext: CMakeExtension) -> None:
+        # Must be in this form due to bug in .resolve() only fixed in Python 3.10+
+        ext_fullpath = Path.cwd() / self.get_ext_fullpath(ext.name)
+        extdir = ext_fullpath.parent.resolve()
+
+        # Using this requires trailing slash for auto-detection & inclusion of
+        # auxiliary "native" libs
+
+        debug = int(os.environ.get("DEBUG", 0)) if self.debug is None else self.debug
+        cfg = "Debug" if debug else "Release"
+
+        # CMake lets you override the generator - we need to check this.
+        # Can be set with Conda-Build, for example.
+        cmake_generator = os.environ.get("CMAKE_GENERATOR", "")
+
+        # Set Python_EXECUTABLE instead if you use PYBIND11_FINDPYTHON
+        # EXAMPLE_VERSION_INFO shows you how to pass a value into the C++ code
+        # from Python.
+        cmake_args = [
+            f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY={extdir}{os.sep}",
+            f"-DPYTHON_EXECUTABLE={sys.executable}",
+            f"-DCMAKE_BUILD_TYPE={cfg}",  # not used on MSVC, but no harm
+        ]
+        build_args = []
+        # Adding CMake arguments set as environment variable
+        # (needed e.g. to build for ARM OSx on conda-forge)
+        if "CMAKE_ARGS" in os.environ:
+            cmake_args += [item for item in os.environ["CMAKE_ARGS"].split(" ") if item]
+
+        # In this example, we pass in the version to C++. You might not need to.
+        cmake_args += [f"-DEXAMPLE_VERSION_INFO={self.distribution.get_version()}"]
+
+        if self.compiler.compiler_type != "msvc":
+            # Using Ninja-build since it a) is available as a wheel and b)
+            # multithreads automatically. MSVC would require all variables be
+            # exported for Ninja to pick it up, which is a little tricky to do.
+            # Users can override the generator with CMAKE_GENERATOR in CMake
+            # 3.15+.
+            if not cmake_generator or cmake_generator == "Ninja":
+                try:
+                    import ninja
+
+                    ninja_executable_path = Path(ninja.BIN_DIR) / "ninja"
+                    cmake_args += [
+                        "-GNinja",
+                        f"-DCMAKE_MAKE_PROGRAM:FILEPATH={ninja_executable_path}",
+                    ]
+                except ImportError:
+                    pass
+
+        else:
+            # Single config generators are handled "normally"
+            single_config = any(x in cmake_generator for x in {"NMake", "Ninja"})
+
+            # CMake allows an arch-in-generator style for backward compatibility
+            contains_arch = any(x in cmake_generator for x in {"ARM", "Win64"})
+
+            # Specify the arch if using MSVC generator, but only if it doesn't
+            # contain a backward-compatibility arch spec already in the
+            # generator name.
+            if not single_config and not contains_arch:
+                cmake_args += ["-A", PLAT_TO_CMAKE[self.plat_name]]
+
+            # Multi-config generators have a different way to specify configs
+            if not single_config:
+                cmake_args += [
+                    f"-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{cfg.upper()}={extdir}"
+                ]
+                build_args += ["--config", cfg]
+
+        if sys.platform.startswith("darwin"):
+            # Cross-compile support for macOS - respect ARCHFLAGS if set
+            archs = re.findall(r"-arch (\S+)", os.environ.get("ARCHFLAGS", ""))
+            if archs:
+                cmake_args += ["-DCMAKE_OSX_ARCHITECTURES={}".format(";".join(archs))]
+
+        # Set CMAKE_BUILD_PARALLEL_LEVEL to control the parallel build level
+        # across all generators.
+        if "CMAKE_BUILD_PARALLEL_LEVEL" not in os.environ:
+            # self.parallel is a Python 3 only way to set parallel jobs by hand
+            # using -j in the build_ext call, not supported by pip or PyPA-build.
+            if hasattr(self, "parallel") and self.parallel:
+                # CMake 3.12+ only.
+                build_args += [f"-j{self.parallel}"]
+
+        build_temp = Path(self.build_temp) / ext.name
+        if not build_temp.exists():
+            build_temp.mkdir(parents=True)
+
+        subprocess.run(
+            ["cmake", ext.sourcedir, *cmake_args], cwd=build_temp, check=True
+        )
+        subprocess.run(
+            ["cmake", "--build", ".", *build_args], cwd=build_temp, check=True
+        )
+
+setuptools.setup(
+    name="pythonknot",
+    version="0.1",
+    author="yjianzhu",
+    author_email="yjianzhu@mail.ustc.edu.cn",
+    description="pythonknot for knot theory calculation",
+    long_description="Python Knot is a Python package for creating and manipulating knots and links, calculating knot invariants, and more.",
+    #packages=setuptools.find_packages(),
+    url = "",
+    ext_modules=[CMakeExtension(name="pythonknot.alexander_poly", sourcedir="src/cpp_module/")],
+    cmdclass={"build_ext": CMakeBuild},
+
+    packages=setuptools.find_packages(where='src'), 
+    package_dir={"": "src"},
+    zip_safe=False,
+    install_requires=[
+        'numpy',
+        'scipy',
+        'pybind11',
+        'rmsd',
+    ],
+)

pythonknot-0.1/src/pythonknot/polymer.py

@@ -0,0 +1,46 @@
+import numpy as np
+
+def bond_length(xyz:np.ndarray,type = "open"):
+    """计算轨迹的键长分布,输入应该为N_frames, N_atoms, 3的numpy array. type="open"表示开链，type="ring"表示闭链."""
+    #print("original shape:", xyz.shape)
+    temp = xyz.transpose(1,2,0)
+    #print("temp shape:", temp.shape)
+    if(type == "ring"):
+        bond_length = np.linalg.norm(temp[1:] - temp[:-1], axis=1)
+        # 闭链需要计算首尾原子的键长
+        end_to_start_bond = np.linalg.norm(temp[-1] - temp[0], axis=0)
+        #print("end_to_start_bond shape:", end_to_start_bond.shape)
+        # 从(N_frames) 变为 (1, N_frames)
+        end_to_start_bond = end_to_start_bond.reshape(1,-1)
+        bond_length = np.concatenate((bond_length, end_to_start_bond), axis=0)
+    elif(type == "open"):
+        bond_length = np.linalg.norm(temp[1:] - temp[:-1], axis=1)
+    print("bond_length shape:", bond_length.shape)
+    bond_length = bond_length.flatten()
+    return bond_length
+
+def radius_of_gyration(trajectory:np.ndarray):
+    """计算轨迹的质心半径分布,输入应该为N_frames, N_atoms, 3的numpy array."""
+    # 计算每帧的质心
+    centroids = np.mean(trajectory, axis=1)
+    
+    # 广播质心回到trajectory的形状，以便进行逐元素操作
+    # centroids[:, np.newaxis, :] 使得 centroids 从 (N_frames, 3) 扩展为 (N_frames, 1, 3)
+    # 这样可以与 trajectory (N_frames, N_atoms, 3) 对齐
+    displacement = trajectory - centroids[:, np.newaxis, :]
+    
+    # 计算每个原子到质心的距离的平方
+    distances_squared = np.sum(displacement**2, axis=2)
+    
+    # 计算每帧的回转半径
+    gyration_radius = np.sqrt(np.mean(distances_squared, axis=1))
+    
+    return gyration_radius
+
+def end_to_end_distance(trajectory:np.ndarray):
+    """计算轨迹的端到端距离分布,输入应该为N_frames, N_atoms, 3的numpy array."""
+    # 计算每帧的端到端距离
+    end_to_end = trajectory[:,-1] - trajectory[:,0]
+    end_to_end_distance = np.linalg.norm(end_to_end, axis=1)
+    
+    return end_to_end_distance

pythonknot-0.1/src/pythonknot/rmsd.py

@@ -0,0 +1,29 @@
+import rmsd
+import numpy
+
+def rmsd_ref(coords,ref):
+    """
+    Calculate the rmsd of coords to ref, and rotate coords to minimize rmsd.
+    """
+
+    rmsd_all = numpy.zeros(coords.shape[0])
+
+    frames, atoms, _ = coords.shape
+    if(ref.shape != coords[0].shape):
+        raise ValueError("The shape of ref and coords should be the same.")
+    
+    ref = ref - numpy.mean(ref, axis=0)
+    
+    # main loop
+    for i in range(frames):
+        # recenter
+        coords[i] -= numpy.mean(coords[i], axis=0)
+
+        # calculate the rotation matrix
+        R = rmsd.kabsch(coords[i], ref)
+        # rotate the coords
+        coords[i] = numpy.dot(coords[i], R)
+        # calculate the rmsd
+        rmsd_all[i] = rmsd.rmsd(coords[i], ref)
+
+    return rmsd_all

pythonknot-0.1/src/pythonknot/xyz.py

@@ -0,0 +1,20 @@
+import numpy as np
+
+def read_xyz(file):
+    """Read xyz file and get all the conf in same file, so return N_frames*n_atoms*3 np array"""
+    with open(file) as f:
+        lines = f.readlines()
+        N_frames = int(len(lines)/(int(lines[0])+2))
+        N_atoms = int(lines[0])
+        print(N_frames, N_atoms)
+        coords = np.zeros((N_frames, N_atoms, 3))
+        for i in range(N_frames):
+            lines = lines[2:]
+            for j in range(N_atoms):
+                line = lines[j].split()
+                coords[i,j,0] = float(line[1])
+                coords[i,j,1] = float(line[2])
+                coords[i,j,2] = float(line[3])
+            lines = lines[N_atoms:]
+
+    return coords

pythonknot-0.1/src/pythonknot.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: pythonknot
+Version: 0.1
+Summary: pythonknot for knot theory calculation
+Home-page: 
+Author: yjianzhu
+Author-email: yjianzhu@mail.ustc.edu.cn
+License: UNKNOWN
+Platform: UNKNOWN
+
+Python Knot is a Python package for creating and manipulating knots and links, calculating knot invariants, and more.
+

pythonknot-0.1/src/pythonknot.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+setup.py
+src/pythonknot/__init__.py
+src/pythonknot/polymer.py
+src/pythonknot/rmsd.py
+src/pythonknot/xyz.py
+src/pythonknot.egg-info/PKG-INFO
+src/pythonknot.egg-info/SOURCES.txt
+src/pythonknot.egg-info/dependency_links.txt
+src/pythonknot.egg-info/not-zip-safe
+src/pythonknot.egg-info/requires.txt
+src/pythonknot.egg-info/top_level.txt
+test/test.py
+test/test2.py

pythonknot-0.1/src/pythonknot.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pythonknot-0.1/src/pythonknot.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

pythonknot-0.1/src/pythonknot.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy
+scipy
+pybind11
+rmsd

pythonknot-0.1/src/pythonknot.egg-info/top_level.txt

@@ -0,0 +1 @@
+pythonknot

pythonknot-0.1/test/test.py

@@ -0,0 +1,7 @@
+import pythonknot
+print(dir(pythonknot))  
+import pythonknot.xyz as xyz
+print(dir(xyz))
+
+import pythonknot.alexander_poly as alexander_poly
+print(dir(alexander_poly))

pythonknot-0.1/test/test2.py

@@ -0,0 +1,5 @@
+# 从.so 文件中导入模块
+import importlib.util
+import sys
+
+spec = importlib.util.spec_from_file_location("pythonknot", "../dist/pythonknot.cpython-37m-x86_64-linux-gnu.so")