MDANCE 0.0.1__py3-none-any.whl

MDANCE-0.0.1.dist-info/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,21 @@
+mdance/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+mdance/inputs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mdance/inputs/preprocess.py,sha256=ZuKLJI0z0SEozFP6fWcAsuRY2pnxoUOWHxFNAHIP9ao,10128
+mdance/modules/PRIME/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mdance/modules/PRIME/rep_frames.py,sha256=MoWypCulyIDcMBydKj34jxdelyuOv_LY35R0g8BQeKQ,5714
+mdance/modules/PRIME/rep_frames_cl.py,sha256=kBKl5I84p-oQ1eJA6LlLiVvTKES5NlQt5QzvcnmIrBA,1495
+mdance/modules/PRIME/sim_calc.py,sha256=rg54-2NfuLKXNyq_JiBtbXxIKyUQDKUKBYhGXu0-o4I,13406
+mdance/modules/PRIME/similarity_cl.py,sha256=nw4Xe3z4-K5jbu1TPjLRlmftSrHikAIu2DZ-y7Gnv5Y,2761
+mdance/modules/kmeansNANI/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mdance/modules/kmeansNANI/nani.py,sha256=bkdBpMyQcWEaZA5HF_YOXF_0azvvdSYUanG7qSwJMgc,10676
+mdance/outputs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mdance/outputs/postprocess.py,sha256=4Bq2U-nS30wRaKA91k-L09Fe6U2FS3bJ9xIMZBReXU4,1255
+mdance/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mdance/tools/bts.py,sha256=ACaO2IoZwL9EmOFOcyvVdTlZCIWi72ly3Llj6RDo4mE,20690
+mdance/tools/esim_modules.py,sha256=UmZv4kgT3-3vPUOEhbsUqCrOoooH9Koed5_OPnBaDQ8,17793
+mdance/tools/isim_modules.py,sha256=rOKFjsCK6gy8Sf4c4gJ7k1cyFcpB1a2xBHS9mcY9M2w,8248
+MDANCE-0.0.1.dist-info/LICENSE,sha256=V7J3Pwcll1WnrOoMh0PnnR1RPudUaioDSxQH7sM46po,1087
+MDANCE-0.0.1.dist-info/METADATA,sha256=dGUcnvHzX1pf1BAvx2velxEJdkD-4r1UVjvk5RtRuOw,4071
+MDANCE-0.0.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+MDANCE-0.0.1.dist-info/top_level.txt,sha256=9e0J6OaYuWt9e4P_kyxCnVl8syLDHZaU3_iXyQqeC4Q,7
+MDANCE-0.0.1.dist-info/RECORD,,

MDANCE-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

MDANCE-0.0.1.dist-info/top_level.txt

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

mdance/__init__.py

@@ -0,0 +1 @@
+

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

mdance/modules/PRIME/rep_frames.py

@@ -0,0 +1,132 @@
+"This script aims to find the representative frame for each method below."""
+from src.tools.esim_modules import calc_medoid
+from src.modules.PRIME.sim_calc import _trim_outliers
+import numpy as np
+import json
+import re
+
+def calculate_max_key(dict):
+    """Find the key with the max value"""
+    max_val = float('-inf')
+    max_key = None
+
+    for k, v in dict.items():
+        for num in v:
+            if num > max_val:
+                max_val = num
+                max_key = k
+
+    max_key = int(re.findall(r'\d+', max_key)[0])
+    return max_key
+
+def gen_all_methods_max(sim_folder='nw', norm_folder='v3_norm', weighted_by_frames=True, 
+                        trim_frac=0.1, n_ary='RR', weight='nw', output_name='rep'):
+    """Generate the representative frame for each method.
+
+    Args:
+        weighted_by_frames (bool, optional): Similarity is weighted by frames. Defaults to True.
+        trim_frac (float, optional): . Defaults to 0.1.
+        n_ary (str, optional): _description_. Defaults to "RR".
+        weight (str, optional): _description_. Defaults to 'nw'.
+        output_name (str, optional): _description_. Defaults to "rep".
+    """
+    if weighted_by_frames is True:
+        w = "w_"
+    elif weighted_by_frames is False:
+        w = ""
+    if trim_frac:
+        t = f"_t{int(float(trim_frac) * 100)}"
+    elif not trim_frac:
+        t= ""
+    with open(f"{sim_folder}/{w}{output_name}_{n_ary}{t}.txt","w") as output:
+        output.write("# Frame number with max values by method: medoid_all, medoid_c0, medoid_c0(trimmed), pairwise, union, medoid, outlier\n")
+        
+        # medoid_all
+        c_all = np.load(f"{norm_folder}/normed_data.npy")
+        output.write(f"{calc_medoid(c_all, n_ary=n_ary, weight=weight)}, ")
+        
+        # medoid_c0 (untrimmed)
+        c0 = np.load(f"{norm_folder}/normed_clusttraj.c0.npy")
+        output.write(f"{calc_medoid(c0, n_ary=n_ary, weight=weight)}, ")
+        
+        # medoid_c0 (trimmed)
+        if not trim_frac:
+            output.write(f"{calc_medoid(c0, n_ary=n_ary, weight=weight)}, ")
+        elif trim_frac:
+            trim_c0 = _trim_outliers(c0, trim_frac=trim_frac, n_ary=n_ary, weight=weight, removal='delete')
+            index = calc_medoid(trim_c0)
+            search = trim_c0[index]
+            new_index = np.where((c0 == search).all(axis=1))[0]
+            output.write(f"{new_index[0]}, ")
+        
+        # pairwise
+        with open(f"{sim_folder}/{w}pairwise_{n_ary}{t}.txt", "r") as file:
+            pairwise = json.load(file)
+        output.write(f"{calculate_max_key(pairwise)}, ")
+
+        # union
+        with open(f"{sim_folder}/{w}union_{n_ary}{t}.txt", "r") as file:
+            union = json.load(file)
+        output.write(f"{calculate_max_key(union)}, ")
+
+        # medoid
+        with open(f"{sim_folder}/{w}medoid_{n_ary}{t}.txt", "r") as file:
+            medoid = json.load(file)
+        output.write(f"{calculate_max_key(medoid)}, ")
+        
+        # outlier
+        with open(f"{sim_folder}/{w}outlier_{n_ary}{t}.txt", "r") as file:
+            outlier = json.load(file)
+        output.write(f"{calculate_max_key(outlier)}")
+
+def gen_one_method_max(method, sim_folder='nw', norm_folder='v3_norm', weighted_by_frames=True, 
+                       trim_frac=0.1, n_ary='RR', weight='nw', output_name='rep'):
+    """Generate the representative frame for each method.
+
+    Args:
+        weighted_by_frames (bool, optional): Similarity is weighted by frames. Defaults to True.
+        trim_frac (float, optional): . Defaults to 0.1.
+        n_ary (str, optional): _description_. Defaults to "RR".
+        weight (str, optional): _description_. Defaults to 'nw'.
+        output_name (str, optional): _description_. Defaults to "rep".
+    """
+    if method not in ['medoid_all', 'medoid_c0', 'medoid_c0(trimmed)', 'pairwise', 'union', 
+                      'medoid', 'outlier']:
+        raise ValueError("Invalid method. Choose from 'medoid_all', 'medoid_c0', \
+                         'medoid_c0(trimmed)', 'pairwise', 'union', 'medoid', 'outlier'")
+    if weighted_by_frames is True:
+        w = "w_"
+    elif weighted_by_frames is False:
+        w = ""
+    if trim_frac:
+        t = f"_t{int(float(trim_frac) * 100)}"
+    elif not trim_frac:
+        t= ""
+    
+    with open(f"{sim_folder}/{w}{output_name}_{n_ary}{t}_{method}.txt","w") as output:
+        output.write(f"# Frame number with max values by method: {method}\n")
+        
+        if method == 'medoid_all':
+            c_all = np.load(f"{norm_folder}/normed_data.npy")
+            output.write(f"{calc_medoid(c_all, n_ary=n_ary, weight=weight)}")
+        
+        elif method == 'medoid_c0':
+            c0 = np.load(f"{norm_folder}/normed_clusttraj.c0")
+            output.write(f"{calc_medoid(c0, n_ary=n_ary, weight=weight)}")
+        
+        elif method == 'medoid_c0(trimmed)':
+            if not trim_frac:
+                raise ValueError("No trimmed frac available")
+            elif trim_frac:
+                trim_c0 = _trim_outliers(c0, trim_frac=trim_frac, n_ary=n_ary, weight=weight, removal='delete')
+                index = calc_medoid(trim_c0)
+                search = trim_c0[index]
+                new_index = np.where((c0 == search).all(axis=1))[0]
+                output.write(f"{new_index[0]}")
+        
+        prime_methods = ['pairwise', 'union', 'medoid', 'outlier']
+
+        if method in prime_methods:
+            with open(f"{sim_folder}/{w}{method}_{n_ary}{t}.txt", "r") as file:
+                data = json.load(file)
+            output.write(f"{calculate_max_key(data)}")

mdance/modules/PRIME/rep_frames_cl.py

@@ -0,0 +1,33 @@
+"""Call the `gen_one_method_max` to generate the method max for a single method 
+or `gen_all_methods_max` to generate the method max for all methods.
+
+Example usage:
+----------------
+No trim, RR index
+>>> python scripts/rep_frames.py
+10% trim, RR index
+>>> python scripts/rep_frames.py -t 0.1
+20% trim, SM index
+>>> python scripts/rep_frames.py -t 0.2 -i SM
+"""
+import sys
+sys.path.insert(0, '../../')
+from src.modules.PRIME.rep_frames import gen_one_method_max, gen_all_methods_max
+import argparse
+
+parser = argparse.ArgumentParser(description='Generate method max with optional trim and n_ary')
+parser.add_argument('-m', '--method', type=str, help='method to use')
+parser.add_argument('-s', '--sim_folder', type=str, help='folder to access')
+parser.add_argument('-t', '--trim_frac', type=float, default=None,
+                    help='Trim parameter for gen_method_max method')
+parser.add_argument('-i', '--index', type=str, default='RR',
+                    help='n_ary parameter for gen_method_max method')
+parser.add_argument('-d', '--norm_folder', type=str, help='norm_folder to access')
+
+args = parser.parse_args()
+if args.method:
+    gen_one_method_max(method=args.method, sim_folder=args.sim_folder, norm_folder=args.norm_folder, 
+                       trim_frac=args.trim_frac, n_ary=args.index)
+else:
+    gen_all_methods_max(sim_folder=args.sim_folder, norm_folder=args.norm_folder, 
+                        trim_frac=args.trim_frac, n_ary=args.index)