rdworks 0.25.7__py3-none-any.whl

rdworks/__init__.py

@@ -0,0 +1,35 @@
+__version__ = '0.25.7'
+
+from rdworks.xml import list_predefined_xml, get_predefined_xml, parse_xml
+from rdworks.units import ev2kcalpermol, hartree2ev, hartree2kcalpermol, periodictable
+from rdworks.readin import read_csv, merge_csv, read_dataframe, read_smi, read_sdf, read_mae 
+from rdworks.std import desalt_smiles, standardize_smiles, standardize
+from rdworks.tautomers import complete_tautomers
+from rdworks.stereoisomers import complete_stereoisomers
+from rdworks.ionized import IonizedStates
+from rdworks.rgroup import expand_rgroup, most_common, most_common_in_NP
+from rdworks.scaffold import scaffold_network, scaffold_tree, BRICS_fragmented, BRICS_fragment_indices
+from rdworks.matchedseries import MatchedSeries
+from rdworks.descriptor import rd_descriptor, rd_descriptor_f
+from rdworks.utils import fix_decimal_places_in_list, fix_decimal_places_in_dict, mae_to_dict, mae_rd_index
+from rdworks.display import svg
+from rdworks.conf import Conf
+from rdworks.mol import Mol
+from rdworks.mollibr import MolLibr
+
+from rdkit import rdBase, RDLogger
+rdkit_logger = RDLogger.logger().setLevel(RDLogger.CRITICAL)
+
+import logging
+
+main_logger = logging.getLogger()
+main_logger.setLevel(logging.INFO) # level: DEBUG < INFO < WARNING < ERROR < CRITICAL
+logger_formatter = logging.Formatter(
+    fmt='%(asctime)s %(levelname)s %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S')
+logger_ch = logging.StreamHandler()
+logger_ch.setFormatter(logger_formatter)
+main_logger.addHandler(logger_ch)
+
+
+__rdkit_version__ = rdBase.rdkitVersion

rdworks/autograph/__init__.py

@@ -0,0 +1,4 @@
+from .nmrclust import NMRCLUST
+from .rckmeans import RCKmeans
+from .dynamictreecut import DynamicTreeCut
+from .autograph import AutoGraph

rdworks/autograph/autograph.py

@@ -0,0 +1,184 @@
+# 2020-04-17
+
+# Kiyoto Aramis Tanemura
+
+# Code for Louvain algorithm was getting lengthy. I dedicate its own module
+
+import numpy as np
+
+from .centroid import centroid_autograph
+
+def getModularity(affinityMatrix, communityAssignments, resolution = 1.0):
+    # Provided an affinity matrix (np.array) and nodes specifying their assigned communities (list),
+    # return the modularity of the whole graph
+    arrayDim = affinityMatrix.shape[0]
+    communities = list(set(communityAssignments))
+    Q = 0
+    affinityMatrix[range(arrayDim), range(arrayDim)] += affinityMatrix[range(arrayDim), range(arrayDim)]
+    two_m = np.sum(affinityMatrix)
+    for C in communities:
+        communityIndices = [i for i in range(len(communityAssignments)) if communityAssignments[i] == C]
+        sigma_in = np.sum(affinityMatrix[communityIndices, :][:, communityIndices])
+        sigma_tot = np.sum(affinityMatrix[communityIndices, :])
+        Q += sigma_in / two_m - resolution * (sigma_tot / two_m) ** 2
+    return Q
+
+def LouvainPhase1(affinityMatrix, communityAssignment, Q_threshold, max_iter, resolution):
+    # inputs: affinityMatrix as numpy array. Clear diagonals prior to entering and filter edges with weights below threshold
+    # communityAssignments: list of length of nodes. Values are community IDs
+    # Q_threshold: minimum global modularity to terminate phase 1
+    # max_iter: number of iteration to force termination of phase 1
+    # output: updated community Assignment list
+
+    num_nodes = affinityMatrix.shape[0]
+
+    affinityMatrix[range(num_nodes), range(num_nodes)] += affinityMatrix[range(num_nodes), range(num_nodes)]
+
+    two_m = np.sum(affinityMatrix)
+
+    modularity_current = getModularity(affinityMatrix, communityAssignment, resolution)
+    changeModularity = 1
+
+    adjacencyMatrix = affinityMatrix > 0
+    iterations = 0
+
+    while changeModularity > Q_threshold and iterations < max_iter:
+        modularity_prev = modularity_current
+        for i in range(num_nodes): # for each node
+            neighborIndices = [j for j in range(num_nodes) if adjacencyMatrix[i,j] == 1]
+            communities = set([communityAssignment[k] for k in neighborIndices])
+            communities.discard(communityAssignment[i])
+            communities = list(communities)
+            modularityList = []
+            # ki: sum of edges incident to node i
+            ki = np.sum(affinityMatrix[i, :])
+            for C in communities:
+                C_members = [x for x in range(num_nodes) if communityAssignment[x] == C]
+                # Sum weights of all edges incident to nodes in C
+                sigma_tot = np.sum(affinityMatrix[C_members, :])
+                # ki_in: sum of weight of edges incident to node i in C
+                ki_in = np.sum(affinityMatrix[i, :][C_members])
+                deltaQ = ki_in/two_m - resolution * sigma_tot * ki / (two_m ** 2 / 2) # simplified formula. Derivation from (https://hal.archives-ouvertes.fr/hal-01231784/document)
+                modularityList.append(deltaQ)
+            modularityList.append(0) # append zero to avoid error by empty list
+            maxQgain = np.max(modularityList)
+            if maxQgain > 0:
+                communityToJoin = communities[modularityList.index(maxQgain)]
+                communityAssignment[i] = communityToJoin
+        modularity_current = getModularity(affinityMatrix, communityAssignment, resolution)
+        changeModularity = modularity_current - modularity_prev
+        iterations += 1
+
+    return communityAssignment
+
+def LouvainPhase2(affinityMatrix, communityAssignment):
+    # Merge each communities into supernodes
+    # input: affinityMatrix or condensed graph
+    # output: condensed graph and list of communities corresponding to the axis of graph
+    num_nodes = affinityMatrix.shape[0]
+    communities = list(set(communityAssignment))
+    num_communities = len(communities)
+    phase2graph = np.zeros([num_communities, num_communities])
+    for i in range(num_communities):
+        i_members = [x for x in range(num_nodes) if communityAssignment[x] == communities[i]]
+        for j in range(num_communities):
+            j_members = [x for x in range(num_nodes) if communityAssignment[x] == communities[j]]
+            phase2graph[i, j] = np.sum(affinityMatrix[i_members, :][:, j_members]) * (1/2) ** (i == j)
+            # if same communities, edges are double counted. If i == j, divide by two
+
+    return phase2graph, communities
+
+
+def Louvain(affinityMatrix, Q_threshold = 0.001, max_iter = 50, resolution = 1.0):
+    # perform the two phases of Louvain community iteratively
+    graph = affinityMatrix
+    comm = list(range(affinityMatrix.shape[0]))
+    # communityAssignmentRecord and commRefList are lists of lists, with same lengths.
+    # communityAssignmentRecord stores assingment after phase 1
+    # commRefList keeps the individual communities before assignment
+    communityAssignmentRecord = []
+    commRefList = []
+    changeModularity = 1
+    iterations = 0
+    while changeModularity > Q_threshold and iterations < max_iter:
+        graph, comm = LouvainPhase2(graph, comm)
+        commRefList.append(list(comm))
+        modularity_past = getModularity(graph, comm, resolution) # Note: we want to compare Q before and after reassignments in phase 1
+        comm = LouvainPhase1(graph, comm, Q_threshold, max_iter, resolution)
+        communityAssignmentRecord.append(list(comm))
+        modularity_curr = getModularity(graph, comm, resolution)
+        changeModularity = modularity_curr - modularity_past
+        iterations += 1
+#        print('changeModularity', changeModularity)
+
+    for i in range(len(communityAssignmentRecord) - 2, 0, -1):
+        changeDict = {}
+        for j in range(len(communityAssignmentRecord[i])):
+            newComm = communityAssignmentRecord[i][j]
+            oldComm = commRefList[i][j]
+            if newComm != oldComm:
+                changeDict[oldComm] = newComm # Change key to value
+
+        for key in changeDict:
+            oldIndices = [x for x in range(len(communityAssignmentRecord[i - 1])) if communityAssignmentRecord[i - 1][x] == key]
+            for j in oldIndices:
+                communityAssignmentRecord[i - 1][j] = changeDict[key]
+    return communityAssignmentRecord[0]
+
+
+def rbfKernel(r, epsilon = 1.0):
+    return np.exp(-(epsilon*r)**2)
+
+
+def findThreshold(affinityMatrix):
+    numFiles = affinityMatrix.shape[0]
+    # Get all values in affinityMatrix. Sort in descending order
+    vals = np.array([])
+    for i in range(numFiles - 1):
+        vals = np.append(vals, affinityMatrix[i, i + 1:])
+
+    vals = np.sort(vals, axis = None)[::-1]
+
+    # Initialize index values
+    upperIndex = 0
+    lowerIndex = len(vals) - 1
+
+    while upperIndex != lowerIndex - 1: # Until the indices are consecutive, iterate
+        midIndex = int(np.mean([lowerIndex, upperIndex]))
+        adjacencyMatrix = affinityMatrix > vals[midIndex]
+        # Will tally nodes visited from first node in graph by BFS. If not all nodes were visited, there are more than one component.
+        nodesVisited = [0] + [i for i in range(numFiles) if adjacencyMatrix[0, i] == 1]
+#        nodesVisited = [i for i in range(numFiles) if adjacencyMatrix[0, i] == 1]
+        for i in nodesVisited:
+            newNodes = [j for j in range(numFiles) if adjacencyMatrix[i, j] == 1 and j not in nodesVisited]
+            nodesVisited += newNodes
+        while len(newNodes) > 0:
+            newNodes1list = []
+            for i in newNodes:
+                newNodes1 = [j for j in range(numFiles) if adjacencyMatrix[i, j] == 1 and j not in nodesVisited]
+                newNodes1list += newNodes1
+                nodesVisited += newNodes1
+
+            newNodes = newNodes1list
+
+        # If every node was visited, then we have exactly one component. Otherwise, there are disconnected graphs
+        if len(nodesVisited) < numFiles:
+            upperIndex = midIndex
+        else:
+            lowerIndex = midIndex
+
+    threshold = vals[lowerIndex]
+
+    return threshold
+
+
+def AutoGraph(rmsdMatrix):
+    N = rmsdMatrix.shape[0]
+    affinityMatrix = rbfKernel(rmsdMatrix)
+    affinityMatrix[range(N), range(N)] = 0 # set diagonal zero
+    threshold = findThreshold(affinityMatrix)
+    adjacencyMatrix = affinityMatrix > threshold
+    filteredAffinityMatrix = affinityMatrix * adjacencyMatrix
+    communityAssignment = Louvain(filteredAffinityMatrix, Q_threshold=0.0, max_iter=50, resolution=1.0)
+    centroid_indices = centroid_autograph(N, communityAssignment, rmsdMatrix, threshold)
+    return communityAssignment, centroid_indices

rdworks/autograph/centroid.py

@@ -0,0 +1,90 @@
+import pandas as pd
+import numpy as np
+
+
+def centroid_medoid(communityAssignment, rmsdMatrix) -> list:
+    """returns a list of centroids based on medoids
+
+    Medoids are representative objects of a data set or a cluster within a data set 
+    whose sum of dissimilarities to all the objects in the cluster is minimal.
+
+    Args:
+        communityAssignment: (list) list of community assignment correspoinding to the index of fileList
+        rmsdMatrix: (numpy array) Matrix containing pairwise atomic RMSD between all conformers
+    
+    Returns:
+        a list of centroids
+    """
+    N = rmsdMatrix.shape[0]
+    community_indices = list(set(communityAssignment))
+    centroids = []
+    for C in community_indices:
+        C_members = [x for x in range(N) if communityAssignment[x] == C]
+        community_submatrix = rmsdMatrix[C_members, :][:, C_members]
+        dist_sum = np.sum(community_submatrix, axis = 1)
+        centroids.append(C_members[np.argmin(dist_sum)])
+    return centroids
+
+
+def diekstra(filtered_rmsd_matrix_community, i):
+    '''Use Dijkstra's algorithm to find shortest path from index i to all other nodes'''
+    # initialize lists
+    visited = []
+    unvisited = [x for x in range(filtered_rmsd_matrix_community.shape[0])]
+    record = [np.inf for x in range(filtered_rmsd_matrix_community.shape[0])]#{x: np.inf for x in range(graph.shape[0])}
+    record[i] = 0
+    lastNode = [-1 for x in record]
+    # repeat until all nodes have been visited
+    while len(unvisited) > 0:
+        visit_index = unvisited[np.argmin([record[x] for x in unvisited])]
+        unvisited_neighbors = [x for x in unvisited if filtered_rmsd_matrix_community[visit_index, x] > 0]
+        # Calculate distance to unvisited neighbor. If value is shorter than recorded, update distance.
+        updateDist = filtered_rmsd_matrix_community[visit_index, :] + record[visit_index]
+        for j in unvisited_neighbors:
+            record[j] = np.min([updateDist[j], record[j]])
+            if updateDist[j] < record[j]:
+                lastNode[j] = visit_index
+        # update visited/unvisited node list
+        unvisited.remove(visit_index)
+        visited.append(visit_index)
+    return record, lastNode
+
+
+def centroid_betweenness(num, communityAssignment, filtered_rmsd_matrix):
+    # Provided with list of conformers assigned to communities, choose representative centroid by conformers of maximum in community betweenness
+    # inputs
+    # fileList: (list) names of xyz files for each conformer
+    # communityAssignment: (list) list of community assignment correspoinding to the index of fileList
+    # filtered_rmsd_matrix: {np.array) RMSD matrix between conformers, except assigning distances above threshold to zero
+    communityList = list(set(communityAssignment))
+    centralNodes = []
+    comm_size = []
+    for C in communityList:
+        C_members = [x for x in range(num) if communityAssignment[x] == C]
+        C_member_files = [x for x in C_members]
+        comm_size.append(len(C_members))
+        community_subgraph = filtered_rmsd_matrix[C_members, :][:, C_members]
+        community_betweenness = np.zeros(len(C_members))
+        for i in range(len(C_member_files)):
+            record, lastnode = diekstra(community_subgraph, i)
+            for j in range(len(C_member_files)):
+                previous_node = lastnode[j]
+                while previous_node != -1:
+                    community_betweenness[previous_node] += 1
+                    previous_node = lastnode[previous_node]
+        max_betweenness_index = np.argmax(community_betweenness)
+        centralNodes.append(C_member_files[max_betweenness_index])
+
+    # Sort centers by size of clusters in descending order
+    centralDf = pd.DataFrame({'size': comm_size}, index = centralNodes)
+    centralDf.sort_values(by = 'size', ascending = False, inplace = True)
+
+    return list(centralDf.index)
+
+
+def centroid_autograph(N, communityAssignment, rmsdMatrix, threshold, centroid_selection='betweenness', filteredAffinityMatrix=None):
+    '''Return file names of conformers designated as centroids. If energy is provided, find lowest energy conformers in each cluster. Otherwise choose by maximum in-cluster weighted degree'''
+    if centroid_selection == 'betweenness':
+        return centroid_betweenness(N, communityAssignment, rmsdMatrix * rmsdMatrix < np.sqrt(-np.log(threshold))) # add filtered rmsd matrix
+    else:
+        print('centroid criterion not recognized. Use keywords "degree", "eccentricity", or "betweenness" for centroid_selection or provide an energy output to base the selection')

rdworks/autograph/dynamictreecut.py

@@ -0,0 +1,135 @@
+# 2020-05-22
+
+# Kiyoto Aramis Tanemura
+
+# The Ward algorithm for conformational clustering is used in building Markov State Model (DOI: 10.1021/acs.jctc.6b01238). To circumvent threshold selection, we will apply the dynamic tree cut method, used in conjunction to the Ward dendogram for automated conformational clustering (DOI: 10.1186/s13321-017-0208-0).
+
+import numpy as np
+
+from scipy.cluster.hierarchy import linkage, to_tree
+from scipy.spatial.distance import squareform
+
+from .centroid import centroid_medoid
+
+
+def get_ward_dendrogram(rmsd_mat):
+    '''Use Scipy functions to obtain dendrogram using Ward method
+    Returns the dendrogram (refer to Scipy linkage output format) as a ClusterNode object'''
+    dend = linkage(squareform(rmsd_mat), method = 'ward', optimal_ordering = True)
+    return dend
+
+
+def goLeftmost(node, path, path_record):
+    '''provided a node, travel left until a leaf is reached'''
+    curr_node = node
+    if path in path_record:
+        return path
+    while not curr_node.is_leaf():
+        curr_node = curr_node.get_left()
+        path += ('l')
+    return path
+
+
+def travelDown(ref_node, rel_path):
+    '''reach a node below, provided a starting node an path'''
+    curr_node = ref_node
+    for i in rel_path:
+        if i == 'l':
+            curr_node = curr_node.get_left()
+        elif i == 'r':
+            curr_node = curr_node.get_right()
+    return curr_node
+
+
+def getHeights(root):
+    '''return heights of nonleaf nodes and their corresponding paths'''
+    heights = []
+    path_recorded = []
+    path = '.'
+    curr_node = root
+    if root.is_leaf():
+        return [0], [path]
+    while 'l' in list(path) or not curr_node.is_leaf():
+        path = goLeftmost(curr_node, path, path_recorded)
+        path = path[:-1]
+        curr_node = travelDown(root, path)
+        if path not in path_recorded:
+            heights.append(curr_node.dist)
+            path_recorded.append(path)
+            path += 'r'
+            curr_node = travelDown(root, path)
+    return heights, path_recorded
+
+
+def treeCutCore(H, I, tau = 5):
+    '''Determine significant clusters provided one calibration value'''
+    H_hat = H - I
+    trans_indices = [x for x in range(len(H)-1) if H_hat[x] > 0 and H_hat[x+1] < 0]
+    breakpoints = []
+    for i in trans_indices:
+        back_index = 1
+        while H_hat[i-back_index] > 0 and back_index <= i:
+            back_index += 1
+        breakpoints.append(i - back_index + 1)
+    # Find significant breakpoints
+    significant_breakpoints = [breakpoints[x] for x in range(len(breakpoints)) if trans_indices[x] - breakpoints[x] > tau]
+    return significant_breakpoints
+
+
+def adaptiveTreecutCore(H, tau = 5):
+    '''Perform treeCutCore at mean height. If no significant breakpoints are detected,
+    continue the operation below and above the mean.'''
+    if len(H) == 0:
+        return []
+    lm = np.mean(H)
+    lu = np.mean([lm, np.max(H)])
+    ld = np.mean([lm, np.min(H)])
+    bps = treeCutCore(H, lm, tau)
+    if len(bps) == 0:
+        bps = treeCutCore(H, ld, tau)
+        if len(bps) == 0:
+            bps = treeCutCore(H, lu, tau)
+    return bps
+
+
+def getClusterNodeIndices(comprehensive_path_list, cluster_substring):
+    # Given a root string, return all permutations as indices
+    return [x for x in range(len(comprehensive_path_list)) if comprehensive_path_list[x].startswith(cluster_substring)]
+
+
+# After looking at the Java implementation, I suspect the breakpoints, corresponding to the indices of heights (distance value of nonleaf nodes),
+# also correspond to the indices of leaves. Try clustering only by collecting all breakpoints, then using the indices to subset leaves.
+def dynamicTreeCut(tree, n, tau = 5):
+    allHeights, allPaths = getHeights(tree)
+    allHeights = [0] + allHeights + [0] # Sandwitch the heights with zero so that the ends can be included or left out from major clusters.
+    breakpoints = [0,-1]
+    updateList = [-1]
+    while len(updateList) > 0:
+        updateList = []
+        for i in range(len(breakpoints) - 1):
+            Hi = allHeights[breakpoints[i]:breakpoints[i+1]]
+            cutpoints = adaptiveTreecutCore(Hi, tau)
+            updateList += [x for x in cutpoints if x not in breakpoints]
+        breakpoints += updateList
+    return breakpoints
+
+
+def report_assingments(breakpoints, tree):
+    '''To standardize outputs with the other clustering algorithms, this function takes the list of ClusterNodes produced in dynamicTreeCut and returns a list of ints specifying the cluster assignment'''
+    leaves = tree.pre_order(lambda x: x.id)
+    n = len(leaves)
+    comm_assing = np.zeros(n, int)
+    for i in range(len(breakpoints) - 1):
+        members = leaves[breakpoints[i]:breakpoints[i+1]]
+        comm_assing[members] = i
+    return comm_assing.tolist()
+
+
+def DynamicTreeCut(rmsdMatrix, tau = 5): # Ward clustering
+    N = rmsdMatrix.shape[0]
+    dend = get_ward_dendrogram(rmsdMatrix)
+    tree = to_tree(dend)
+    breakpoints = dynamicTreeCut(tree, N, tau)
+    communityAssignment = report_assingments(breakpoints, tree)
+    centroid_indices = centroid_medoid(communityAssignment, rmsdMatrix)
+    return communityAssignment, centroid_indices

rdworks/autograph/nmrclust.py

@@ -0,0 +1,123 @@
+# 2020-04-29
+
+# Kiyoto Aramis Tanemura
+
+# NMRCLUST algorithm implemented in python using numpy. Original algorithm DOI: 10.1093/protein/9.11.1063
+# To use in your code, first compute rmsdMatrix
+# Then 'communityAssignment = NRMCLUST(rmsdMatrix)'
+# The file list corresponding to the axis of the rmsdMatrix will be assigned to clusters specified in communityAssignment
+
+import numpy as np
+
+from .centroid import centroid_medoid
+
+
+def averageLinkage(rmsdMatrix, clusterXmembers, clusterYmembers):
+    subgraph = rmsdMatrix[clusterXmembers,:][:,clusterYmembers]
+    return np.mean(subgraph)
+
+
+def spread(rmsdMatrix, members):
+    subgraph = rmsdMatrix[members,:][:,members]
+    N = len(members)
+    offDiagonalSum = np.sum(subgraph) / 2 # note: diagonals are zero
+    return offDiagonalSum / (N * (N-1) / 2)
+
+
+def memberIndices(communityID, communityAssignment):
+    indices = [x for x in range(len(communityAssignment)) if communityAssignment[x] == communityID]
+    return indices
+
+
+def averageSpread(rmsdMatrix, communityAssignment):
+    communities = list(set(communityAssignment))
+    spreads = [spread(rmsdMatrix, memberIndices(C, communityAssignment)) for C in communities]
+    return np.mean(spreads)
+
+
+def mergeClusters(rmsdMatrix, communityAssignment, aveLinkArray = None):
+    communities = list(set(communityAssignment))
+    numCommunities = len(communities)
+    if type(aveLinkArray) == type(None):
+        aveLinkArray = np.zeros([numCommunities, numCommunities])
+        for i in range(numCommunities - 1):
+            for j in range(i + 1, numCommunities):
+                i_members = memberIndices(communities[i], communityAssignment)
+                j_members = memberIndices(communities[j], communityAssignment)
+                aveLinkVal = averageLinkage(rmsdMatrix, i_members, j_members)
+                aveLinkArray[i,j] = aveLinkVal
+                aveLinkArray[j,i] = aveLinkVal
+
+    # Populate diagonals (self similarity) with max average linkage value to remove it from consideration.
+    aveLinkArray[range(numCommunities), range(numCommunities)] = np.max(aveLinkArray) + 0.01
+    minVal = np.min(aveLinkArray)
+    # Find value of minimum average linkage. Keep only the first index
+    i, j = np.where(aveLinkArray == minVal)
+    i = i[0]
+    j = j[0]
+    # Merge communities as recorded on communityAssignment
+    C = communities[i]
+    G = communities[j]
+    i_members=memberIndices(communities[i], communityAssignment)
+    j_members=memberIndices(communities[j], communityAssignment)
+    for mem in j_members:
+        communityAssignment[mem] = C
+
+    for k in range(numCommunities):
+        if communities[k] in [C, G]:
+            continue
+        k_members = memberIndices(communities[k], communityAssignment)
+        aveLinkVal = averageLinkage(rmsdMatrix, i_members+j_members, k_members)
+        aveLinkArray[i, k] = aveLinkVal
+        aveLinkArray[k, i] = aveLinkVal
+
+    aveLinkArray = np.delete(aveLinkArray, j, 0)
+    aveLinkArray = np.delete(aveLinkArray, j, 1)
+
+    return communityAssignment, aveLinkArray
+
+
+def normalizeAvSpVal(AvSpVal, AvSpMax, AvSpMin, N):
+    return (N - 1) / (AvSpMax - AvSpMin) * (AvSpVal - AvSpMin) + 1
+
+
+def normalizeAvSp(AvSpList, N):
+    AvSpMax = np.max(AvSpList)
+    AvSpMin = np.min(AvSpList)
+    if AvSpMax == AvSpMin:
+        return [1 for x in AvSpList]
+    return [normalizeAvSpVal(x, AvSpMax, AvSpMin, N) for x in AvSpList]
+
+
+def NMRCLUST(rmsdMatrix):
+    N = rmsdMatrix.shape[0]
+    AvSpList = []
+    assignList = []
+    aveLinkArray = None
+    communityAssignment = list(range(N))
+    singletonPresent = True # spread cannot be calculated if size of cluster is 1. Avoid spread calculation until each cluster has at least 2 members
+    while singletonPresent:
+        communityAssignment, aveLinkArray = mergeClusters(rmsdMatrix, communityAssignment, aveLinkArray)
+        communities = list(set(communityAssignment))
+        commcount = [len([x for x in communityAssignment if x == C]) for C in communities]
+        if 1 not in commcount:
+            singletonPresent = False
+        elif len(communities) == 2:
+            singletonPresent = False
+
+    # Begin recording Average spread and cumminities assignment once singletons are absent
+    # Continue recording until all are merged into one cluster
+    while len(set(communityAssignment)) > 1:
+        communityAssignment, aveLinkArray = mergeClusters(rmsdMatrix, communityAssignment, aveLinkArray)
+        AvSpList.append(float(averageSpread(rmsdMatrix, communityAssignment)))
+        assignList.append(list(communityAssignment))
+
+    nClustList = [len(set(x)) for x in assignList] # number of clusters from when it was began recoded to one cluster, decreasing by one cluster at each step
+    AvSpNormList = normalizeAvSp(AvSpList, N)
+    penaltyVals = [AvSpNormList[x] + nClustList[x] for x in range(len(AvSpNormList))]
+    minPenalty = np.min(penaltyVals)
+    minPenaltyIndex = penaltyVals.index(minPenalty)
+    communityAssignment = assignList[minPenaltyIndex]
+    centroid_indices = centroid_medoid(communityAssignment, rmsdMatrix)
+
+    return communityAssignment, centroid_indices

rdworks/autograph/rckmeans.py

@@ -0,0 +1,74 @@
+# 2020-05-20
+
+# Kiyoto Aramis Tanemura
+
+# We consider the use of representative conformation K-means to benchmark against AutoGraph as a method which does not require specification of number of clusters or threshold.
+# Original algorithm found at DOI: 10.1186/s13321-017-0208-0
+
+import numpy as np
+from random import sample
+from math import factorial
+
+def kmedoid(rmsdMatrix, k = 2):
+    # Generic k-medoid function with rmsd matrix as input
+    n = rmsdMatrix.shape[0]
+    medoids = sample(range(n), k)
+    prev_medoids = []
+    classification = np.zeros(n, dtype = int).tolist()
+    while medoids != prev_medoids:
+        for i in range(n):
+            prev_medoids = medoids
+            min_index = np.argmin(rmsdMatrix[i,:][medoids])
+            classification[i] = min_index
+        for j in range(k):
+            members = [x for x in range(n) if classification[x] == j]
+            sub_rmsd = rmsdMatrix[members,:][:, members]
+            center_index = np.argmin(np.sum(sub_rmsd, axis = 0))
+            medoids[j] = center_index
+
+    return classification, medoids
+
+
+def comb(n, r):
+    if n < r:
+        return 1
+    return factorial(n) / (factorial(r) * factorial(n-r))
+
+
+def MSQb(rmsdMatrix, medoids):
+    sub_rmsd = rmsdMatrix[medoids, :][:, medoids]
+    return np.sum(sub_rmsd) / (2 * comb(len(medoids), 2))
+
+
+def MSQw(rmsdMatrix,classification):
+    tally = 0
+    n = len(classification)
+    for i in set(classification):
+        members = [x for x in range(n) if classification[x] == i]
+        sub_rmsd = rmsdMatrix[members, :][:, members]
+        tally += np.sum(sub_rmsd) / (2 * comb(len(members), 2))
+    return tally / len(set(classification))
+
+
+def SMA(MSQb_list, W = 10):
+    if len(MSQb_list) >= W:
+        return np.mean(MSQb_list[-10:])
+    return -1
+
+
+def RCKmeans(rmsdMatrix):
+    m = rmsdMatrix.shape[0]
+    K_MSQb = [0, 0]
+    prevSMA = -1
+    for k in range(2,m):
+        MSQw_list = np.zeros(100, dtype = int).tolist()
+        MSQb_list = np.zeros(100, dtype = int).tolist()
+        for i in range(100):
+            classification, medoids = kmedoid(rmsdMatrix, k)
+            MSQw_list[i] = MSQw(rmsdMatrix, classification)
+            MSQb_list[i] = MSQb(rmsdMatrix, medoids)
+        K_MSQb.append(MSQb_list[np.argmin(MSQw_list)])
+        currSMA = SMA(K_MSQb, 10)
+        if currSMA < prevSMA:
+            return kmedoid(rmsdMatrix, np.argmax(K_MSQb))
+        prevSMA = currSMA

rdworks/bitqt/__init__.py

@@ -0,0 +1 @@
+from .bitqt import BitQT, get_cluster_stats