MDANCE 0.0.1__tar.gz

mdance-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 mqcomplab
+
+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.

mdance-0.0.1/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.1
+Name: MDANCE
+Version: 0.0.1
+Summary: flexible n-ary clustering package for all applications.
+Author-email: Lexin Chen <lxchen017@gmail.com>
+Project-URL: Homepage, https://github.com/mqcomplab/MDANCE
+Project-URL: Issues, https://github.com/mqcomplab/MDANCE/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Molecular Dynamics Analysis with *N*-ary Clustering Ensembles (MDANCE)
+Molecular Dynamics Analysis with *N*-ary Clustering Ensembles (MDANCE) is a flexible *n*-ary clustering package that provides a set of tools for clustering Molecular Dynamics trajectories. The package is written in Python and an extension of the *n*-ary similarity framework. The package is designed to be modular and extensible, allowing for the addition of new clustering algorithms and similarity metrics.
+
+## Table of Contents
+- [Background](#background)
+- [Clustering Algorithms](#clustering-algorithms)
+  - [NANI](#nani)
+- [Clustering Postprocessing](#clustering-postprocessing)
+  - [PRIME](#prime)
+- [Installation](#installation)
+
+## Background
+Molecular Dynamics (MD) simulations are a powerful tool for studying the dynamics of biomolecules. However, the analysis of MD trajectories is challenging due to the large amount of data generated. Clustering is an unsupervised machine learning approach to group similar frames into clusters. The clustering results can be used to reveal the structure of the data, identify the most representative structures, and to study the dynamics of the system.
+
+## Installation
+```
+pip install mdance
+```
+To check for proper installation, run the following command:
+```python
+import mdance
+print(mdance.__version__)
+```
+
+## Clustering Algorithms
+### NANI
+<p align="center">
+<img src="img/nani-logo.PNG" width="200" height=auto align="center"></a></p>
+
+<h3 align="center">
+    <p><b>🪄NANI🪄the first installment of MDANCE</b></p>
+    </h3>
+
+*k*-Means *N*-Ary Natural Initiation (NANI) is an algorithm for selecting initial centroids for *k*-Means clustering. NANI is an extension of the *k*-Means++ algorithm. NANI stratifies the data to high density region and perform diversity selection on top of the it to select the initial centroids. This is a deterministic algorithm that will always select the same initial centroids for the same dataset and improve on *k*-means++ by reducing the number of iterations required to converge and improve the clustering quality.
+
+**[A tutorial is available for NANI](https://github.com/mqcomplab/MDANCE/blob/main/tutorials/nani.md).**
+
+For more information on the NANI algorithm, please refer to the [NANI paper](https://www.biorxiv.org/content/10.1101/2024.03.07.583975v1). 
+
+
+## Clustering Postprocessing
+### PRIME
+<h3 align="center"> 
+    <img src="img/logo.png" width="800" height=auto align="center"></a>
+    &nbsp
+    <p><b>🪄 Predict Protein Structure with Precision 🪄</b></p>
+    </h3>
+
+<table>
+  <tr>
+    <td>
+      <p>Protein Retrieval via Integrative Molecular Ensembles (PRIME)</b> is a novel algorithm that predicts the native structure of a protein from simulation or clustering data. These methods perfectly mapped all the structural motifs in the studied systems and required unprecedented linear scaling.</p>
+    </td>
+    <td>
+      <figure>
+        <img src="img/2k2e.png" alt="2k2e" width="300" height="auto">
+        <figcaption><i>Fig 1. Superposition of the most representative structures found with extended indices (yellow) and experimental native structures (blue) of 2k2e.</i></figcaption>
+      </figure>
+    </td>
+  </tr>
+</table>
+
+**[A tutorial is available for PRIME](https://github.com/mqcomplab/MDANCE/blob/main/tutorials/prime.md).**
+
+For more information on the PRIME algorithm, please refer to the [PRIME paper](https://www.biorxiv.org/content/10.1101/2024.03.19.585783v1). 
+

mdance-0.0.1/README.md

@@ -0,0 +1,66 @@
+# Molecular Dynamics Analysis with *N*-ary Clustering Ensembles (MDANCE)
+Molecular Dynamics Analysis with *N*-ary Clustering Ensembles (MDANCE) is a flexible *n*-ary clustering package that provides a set of tools for clustering Molecular Dynamics trajectories. The package is written in Python and an extension of the *n*-ary similarity framework. The package is designed to be modular and extensible, allowing for the addition of new clustering algorithms and similarity metrics.
+
+## Table of Contents
+- [Background](#background)
+- [Clustering Algorithms](#clustering-algorithms)
+  - [NANI](#nani)
+- [Clustering Postprocessing](#clustering-postprocessing)
+  - [PRIME](#prime)
+- [Installation](#installation)
+
+## Background
+Molecular Dynamics (MD) simulations are a powerful tool for studying the dynamics of biomolecules. However, the analysis of MD trajectories is challenging due to the large amount of data generated. Clustering is an unsupervised machine learning approach to group similar frames into clusters. The clustering results can be used to reveal the structure of the data, identify the most representative structures, and to study the dynamics of the system.
+
+## Installation
+```
+pip install mdance
+```
+To check for proper installation, run the following command:
+```python
+import mdance
+print(mdance.__version__)
+```
+
+## Clustering Algorithms
+### NANI
+<p align="center">
+<img src="img/nani-logo.PNG" width="200" height=auto align="center"></a></p>
+
+<h3 align="center">
+    <p><b>🪄NANI🪄the first installment of MDANCE</b></p>
+    </h3>
+
+*k*-Means *N*-Ary Natural Initiation (NANI) is an algorithm for selecting initial centroids for *k*-Means clustering. NANI is an extension of the *k*-Means++ algorithm. NANI stratifies the data to high density region and perform diversity selection on top of the it to select the initial centroids. This is a deterministic algorithm that will always select the same initial centroids for the same dataset and improve on *k*-means++ by reducing the number of iterations required to converge and improve the clustering quality.
+
+**[A tutorial is available for NANI](https://github.com/mqcomplab/MDANCE/blob/main/tutorials/nani.md).**
+
+For more information on the NANI algorithm, please refer to the [NANI paper](https://www.biorxiv.org/content/10.1101/2024.03.07.583975v1). 
+
+
+## Clustering Postprocessing
+### PRIME
+<h3 align="center"> 
+    <img src="img/logo.png" width="800" height=auto align="center"></a>
+    &nbsp
+    <p><b>🪄 Predict Protein Structure with Precision 🪄</b></p>
+    </h3>
+
+<table>
+  <tr>
+    <td>
+      <p>Protein Retrieval via Integrative Molecular Ensembles (PRIME)</b> is a novel algorithm that predicts the native structure of a protein from simulation or clustering data. These methods perfectly mapped all the structural motifs in the studied systems and required unprecedented linear scaling.</p>
+    </td>
+    <td>
+      <figure>
+        <img src="img/2k2e.png" alt="2k2e" width="300" height="auto">
+        <figcaption><i>Fig 1. Superposition of the most representative structures found with extended indices (yellow) and experimental native structures (blue) of 2k2e.</i></figcaption>
+      </figure>
+    </td>
+  </tr>
+</table>
+
+**[A tutorial is available for PRIME](https://github.com/mqcomplab/MDANCE/blob/main/tutorials/prime.md).**
+
+For more information on the PRIME algorithm, please refer to the [PRIME paper](https://www.biorxiv.org/content/10.1101/2024.03.19.585783v1). 
+

mdance-0.0.1/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "MDANCE"
+version = "0.0.1"
+authors = [
+  { name="Lexin Chen", email="lxchen017@gmail.com" },
+]
+description = "flexible n-ary clustering package for all applications."
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/mqcomplab/MDANCE"
+Issues = "https://github.com/mqcomplab/MDANCE/issues"

mdance-0.0.1/setup.cfg

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

mdance-0.0.1/src/MDANCE.egg-info/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.1
+Name: MDANCE
+Version: 0.0.1
+Summary: flexible n-ary clustering package for all applications.
+Author-email: Lexin Chen <lxchen017@gmail.com>
+Project-URL: Homepage, https://github.com/mqcomplab/MDANCE
+Project-URL: Issues, https://github.com/mqcomplab/MDANCE/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Molecular Dynamics Analysis with *N*-ary Clustering Ensembles (MDANCE)
+Molecular Dynamics Analysis with *N*-ary Clustering Ensembles (MDANCE) is a flexible *n*-ary clustering package that provides a set of tools for clustering Molecular Dynamics trajectories. The package is written in Python and an extension of the *n*-ary similarity framework. The package is designed to be modular and extensible, allowing for the addition of new clustering algorithms and similarity metrics.
+
+## Table of Contents
+- [Background](#background)
+- [Clustering Algorithms](#clustering-algorithms)
+  - [NANI](#nani)
+- [Clustering Postprocessing](#clustering-postprocessing)
+  - [PRIME](#prime)
+- [Installation](#installation)
+
+## Background
+Molecular Dynamics (MD) simulations are a powerful tool for studying the dynamics of biomolecules. However, the analysis of MD trajectories is challenging due to the large amount of data generated. Clustering is an unsupervised machine learning approach to group similar frames into clusters. The clustering results can be used to reveal the structure of the data, identify the most representative structures, and to study the dynamics of the system.
+
+## Installation
+```
+pip install mdance
+```
+To check for proper installation, run the following command:
+```python
+import mdance
+print(mdance.__version__)
+```
+
+## Clustering Algorithms
+### NANI
+<p align="center">
+<img src="img/nani-logo.PNG" width="200" height=auto align="center"></a></p>
+
+<h3 align="center">
+    <p><b>🪄NANI🪄the first installment of MDANCE</b></p>
+    </h3>
+
+*k*-Means *N*-Ary Natural Initiation (NANI) is an algorithm for selecting initial centroids for *k*-Means clustering. NANI is an extension of the *k*-Means++ algorithm. NANI stratifies the data to high density region and perform diversity selection on top of the it to select the initial centroids. This is a deterministic algorithm that will always select the same initial centroids for the same dataset and improve on *k*-means++ by reducing the number of iterations required to converge and improve the clustering quality.
+
+**[A tutorial is available for NANI](https://github.com/mqcomplab/MDANCE/blob/main/tutorials/nani.md).**
+
+For more information on the NANI algorithm, please refer to the [NANI paper](https://www.biorxiv.org/content/10.1101/2024.03.07.583975v1). 
+
+
+## Clustering Postprocessing
+### PRIME
+<h3 align="center"> 
+    <img src="img/logo.png" width="800" height=auto align="center"></a>
+    &nbsp
+    <p><b>🪄 Predict Protein Structure with Precision 🪄</b></p>
+    </h3>
+
+<table>
+  <tr>
+    <td>
+      <p>Protein Retrieval via Integrative Molecular Ensembles (PRIME)</b> is a novel algorithm that predicts the native structure of a protein from simulation or clustering data. These methods perfectly mapped all the structural motifs in the studied systems and required unprecedented linear scaling.</p>
+    </td>
+    <td>
+      <figure>
+        <img src="img/2k2e.png" alt="2k2e" width="300" height="auto">
+        <figcaption><i>Fig 1. Superposition of the most representative structures found with extended indices (yellow) and experimental native structures (blue) of 2k2e.</i></figcaption>
+      </figure>
+    </td>
+  </tr>
+</table>
+
+**[A tutorial is available for PRIME](https://github.com/mqcomplab/MDANCE/blob/main/tutorials/prime.md).**
+
+For more information on the PRIME algorithm, please refer to the [PRIME paper](https://www.biorxiv.org/content/10.1101/2024.03.19.585783v1). 
+

mdance-0.0.1/src/MDANCE.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+src/MDANCE.egg-info/PKG-INFO
+src/MDANCE.egg-info/SOURCES.txt
+src/MDANCE.egg-info/dependency_links.txt
+src/MDANCE.egg-info/top_level.txt
+src/mdance/__init__.py
+src/mdance/inputs/__init__.py
+src/mdance/inputs/preprocess.py
+src/mdance/modules/PRIME/__init__.py
+src/mdance/modules/PRIME/rep_frames.py
+src/mdance/modules/PRIME/rep_frames_cl.py
+src/mdance/modules/PRIME/sim_calc.py
+src/mdance/modules/PRIME/similarity_cl.py
+src/mdance/modules/kmeansNANI/__init__.py
+src/mdance/modules/kmeansNANI/nani.py
+src/mdance/outputs/__init__.py
+src/mdance/outputs/postprocess.py
+src/mdance/tools/__init__.py
+src/mdance/tools/bts.py
+src/mdance/tools/esim_modules.py
+src/mdance/tools/isim_modules.py

mdance-0.0.1/src/MDANCE.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mdance-0.0.1/src/MDANCE.egg-info/top_level.txt

@@ -0,0 +1 @@
+mdance

mdance-0.0.1/src/mdance/__init__.py

@@ -0,0 +1 @@
+

mdance-0.0.1/src/mdance/inputs/preprocess.py

@@ -0,0 +1,239 @@
+import glob
+from itertools import chain
+import MDAnalysis as mda
+import numpy as np
+import re
+
+def gen_traj_numpy(prmtopFileName, trajFileName, atomSel):
+    """Reads in a trajectory and returns a 2D numpy array of the coordinates 
+    of the selected atoms.
+    
+    Parameters
+    ----------
+    prmtopFileName : str
+        The file path of the topology file.
+    trajFileName : str
+        The file path of the trajectory file.
+    atomSel : str
+        The atom selection string. For example, 'resid 3:12 and name N H CA C O'.
+        View details in the MDAnalysis documentation: 
+        https://docs.mdanalysis.org/stable/documentation_pages/selections.html
+
+    Returns
+    -------
+    traj_numpy : np.ndarray
+        The 2D numpy array of the coordinates of the selected atoms.
+        
+    Examples
+    --------
+    >>> traj_numpy = gen_traj_numpy('aligned_tau.pdb', 'aligned_tau.dcd', 
+                                    'resid 3:12 and name N CA C')
+    """
+    coord = mda.Universe(prmtopFileName,trajFileName)
+    print('Number of atoms in trajectory:', coord.atoms.n_atoms)
+    print('Number of frames in trajectory:', coord.trajectory.n_frames)
+    atomSel = coord.select_atoms(atomSel)
+    print('Number of atoms in selection:', atomSel.n_atoms)
+    # Create traj data of the atom selection
+    traj_numpy = np.empty((coord.trajectory.n_frames,atomSel.n_atoms, 3), dtype=float)
+    # Loop every frame and store the coordinates of the atom selection
+    for ts in coord.trajectory:
+        traj_numpy[ts.frame,:] = atomSel.positions
+    # Flatten 3D array to 2D array
+    traj_numpy = traj_numpy.reshape(traj_numpy.shape[0],-1)
+    return traj_numpy
+
+class Normalizer:
+    """Class for normalizing data from cpptraj CRD/MDCRD files.
+
+    Attributes
+    ----------
+    file_path : str, optional
+        The file path of the input data. If provided, the data is read from
+        the file. Defaults to None.
+    data : array_like of shape (n_samples, n_features), optional
+        The input data as a numpy array. If provided, the file_path argument
+        is ignored. Defaults to None.
+    custom_min : float or None, optional
+        The minimum value to use for normalization. If not provided, 
+        the minimum value of the input data is used. Defaults to None.
+    custom_max : float or None, optional
+        The maximum value to use for normalization. If not provided,
+        the maximum value of the input data is used. Defaults to None.
+    normed_data : np.ndarray
+        The normalized input data as a numpy array.
+    c_total : np.ndarray
+        The sum of columns of the normalized input data.
+    min : float
+        The minimum value of the input data.
+    max : float
+        The maximum value of the input data.
+    
+    Methods
+    -------
+    get_min_max()
+        Returns the minimum and maximum values of the input data.
+    get_v2_norm()
+        Returns the v2 normalized data.
+    get_v3_norm()
+        Returns the v3 normalized data.
+    get_c_total()
+        Returns the c_total values.
+    """ 
+    def __init__(self, file_path=None, data=None, custom_min=None, custom_max=None, custom_avg=None):
+        """Initialize the Normalizer class.
+        
+        Parameters
+        ----------
+        file_path : str, optional
+            The file path of the input data. If provided, the data is read from
+            the file. Defaults to None.
+        data : array_like of shape (n_samples, n_features), optional
+            The input data as a numpy array. If provided, the file_path argument
+            is ignored. Defaults to None.
+        custom_min : {float, None}, optional
+            The minimum value to use for normalization. If not provided, 
+            the minimum value of the input data is used. Defaults to None.
+        custom_max : {float, None}, optional
+            The maximum value to use for normalization. If not provided,
+            the maximum value of the input data is used. Defaults to None.
+        custom_avg : {float, None}, optional
+            The average value to use for normalization. If not provided,
+            the average value of the input data is used. Defaults to None.
+        """
+        if file_path:
+            self.file_path = file_path
+            self.data = np.genfromtxt(self.file_path)
+        elif data is not None:
+            self.data = data
+        if custom_min and custom_max:
+            self.min = custom_min
+            self.max = custom_max
+        else:
+            self.min = np.min(self.data)
+            self.max = np.max(self.data)
+
+        self.v3_norm = (self.data - self.min) / (self.max - self.min)
+        if custom_avg is not None:
+            self.avg = custom_avg
+        else:
+            self.avg = np.mean(self.v3_norm, axis=0)
+        self.v2_norm = 1 - np.abs(self.v3_norm - self.avg)
+        self.c_total = np.sum(1 - np.abs(self.v3_norm - np.mean(self.v3_norm, axis=0)), axis=0)
+    
+    def get_min_max(self):
+        """Returns the minimum and maximum values of the input data."""
+        return self.min, self.max, self.avg
+    
+    def get_v2_norm(self):
+        """Returns the 'v2' normalized data."""
+        return self.v2_norm
+    
+    def get_v3_norm(self):
+        """Returns the 'v3' normalized data."""
+        return self.v3_norm
+    
+    def get_c_total(self):
+        """Returns the 'c_total' values."""
+        return self.c_total
+
+def read_cpptraj(break_line=None, norm_type=None, min=None, max=None, avg=None, normalize=False):
+    """Read multiple AMBER CRD files to convert to numpy ndarray formatting and normalize the data.
+    
+    Parameters
+    ----------
+    break_line : int
+        The number of columns per line of the input file. (have to n-1 because ignore first line)
+    norm_type : str
+        The type of normalization to use. Can be "v2" or "v3".
+    min : float or None, optional
+        The minimum value to use for normalization. If not provided,
+        the minimum value of the input data is used. Defaults to None.
+    max : float or None, optional
+        The maximum value to use for normalization. If not provided,
+        the maximum value of the input data is used. Defaults to None.
+    avg : float or None, optional
+        The average value to use for normalization. If not provided,
+        the average value of the input data is used. Defaults to None.
+    normalize : bool, optional
+        Whether to normalize the input data. If True, the data is
+        normalized to the range [0, 1]. Defaults to False.
+    
+    Returns
+    -------
+    np.ndarray
+        The concatenated input data as a numpy array.
+    """
+    input_files = sorted(glob.glob("clusttraj.c*"), key=lambda x: int(re.findall("\d+", x)[0]))
+    break_line = break_line
+    frames_list = []
+    count_frames = []
+    for file in input_files:
+        with open(file, 'r') as infile:
+            lines = [line.rstrip() for line in infile][1:]
+        sep_lines = [[line[i:i+8] for i in range(0, len(line), 8)] for line in lines]
+        chunks = [sep_lines[i:i+break_line] for i in range(0, len(sep_lines), break_line)]
+        str_frames = [list(chain.from_iterable(chunk)) for chunk in chunks]
+        str_frames = [' '.join(frame) for frame in str_frames]
+        frames = np.array([np.fromstring(frame, dtype='float32', sep=' ') for frame in str_frames])
+        if normalize:
+            norm = Normalizer(data=frames, custom_min=min, custom_max=max, custom_avg=avg)
+            if norm_type == "v2":
+                normed_frame = norm.get_v2_norm()
+            elif norm_type == "v3":
+                normed_frame = norm.get_v3_norm()
+            np.savetxt(f"normed_{file}", normed_frame)
+        else:
+            frames_list.append(frames)
+        count_frames.append(len(frames))
+    if not normalize:
+        data = np.concatenate(frames_list, axis=0)
+        return data
+
+def normalize_file(file, break_line=None, norm_type=None): 
+    """Normalize a single file and output the normalized data to a new file.
+    
+    Parameters
+    ----------
+    file : str
+        The file path of the input data.
+    output : str
+        The file path of the output data.
+    break_line : int
+        The number of columns per line of the input file. (have to n-1 because ignore first line)
+    norm_type : str
+        The type of normalization to use. Can be "v2" or "v3".
+    min : float or None, optional
+        The minimum value to use for normalization. If not provided,
+        the minimum value of the input data is used. Defaults to None.
+    max : float or None, optional
+        The maximum value to use for normalization. If not provided,
+        the maximum value of the input data is used. Defaults to None.
+    avg : float or None, optional
+        The average value to use for normalization. If not provided,
+        the average value of the input data is used. Defaults to None.
+    
+    Returns
+    -------
+    tuple
+        The minimum, maximum, and average values of the input data.
+    """
+    if file is not isinstance(file, str):
+        frames = file
+    if break_line:
+        break_line = break_line
+        with open(file, 'r') as infile:
+            lines = [line.rstrip() for line in infile][1:]
+        sep_lines = [[line[i:i+8] for i in range(0, len(line), 8)] for line in lines]
+        chunks = [sep_lines[i:i+break_line] for i in range(0, len(sep_lines), break_line)]
+        str_frames = [list(chain.from_iterable(chunk)) for chunk in chunks]
+        str_frames = [' '.join(frame) for frame in str_frames]
+        frames = np.array([np.fromstring(frame, dtype='float32', sep=' ') for frame in str_frames])
+    if norm_type == "v2":
+        norm = Normalizer(data=frames)
+        normed_frame = norm.get_v2_norm()
+    elif norm_type == "v3":
+        norm = Normalizer(data=frames)
+        normed_frame = norm.get_v3_norm()
+    min, max, avg = norm.get_min_max()
+    return normed_frame, min, max, avg