Bugfix concorrenza visualizzazione

Author: AlessioDelConte

correlation_window.py

@@ -56,10 +56,10 @@ def create_table(self, obj):
             tableWidget.setSortingEnabled(False)
 
             rowPosition = tableWidget.rowCount()  # necessary even when there are no rows in the table
+            df_of_interacton = pd.DataFrame([edge1s, freqs1, inter_labels, edge2s, freqs2, corr_vals, p_vals]).transpose()
+            df = df.append(df_of_interacton)
 
-            df = df.append(pd.DataFrame([edge1s, freqs1, inter_labels, edge2s, freqs2, corr_vals, p_vals]).transpose())
-
-            self.parent.log("{} {} interactions correlates/anti-correlates".format(len(df), inter))
+            self.parent.log("{} {} interactions correlates/anti-correlates".format(len(df_of_interacton), inter))
 
         df = df.sort_values([0, 3, 5], ascending=(True, True, False))
 
@@ -147,11 +147,11 @@ def show_corr_fn(self):
             else:
                 anti_set.add(edge2)
 
-        self.parent.visualize(selection="edge1", color="white", int_type=inter, edge_set=sele_set)
+        self.parent.visualize(selection="edge1", color="white", int_type=inter)
         if len(corr_set) > 0:
-            self.parent.visualize(selection="edge2", color="blue", int_type=inter, edge_set=corr_set)
+            self.parent.visualize(selection="edge2", color="blue", int_type=inter)
         if len(anti_set) > 0:
-            self.parent.visualize(selection="edge2", color="red", int_type=inter, edge_set=anti_set)
+            self.parent.visualize(selection="edge2", color="red", int_type=inter)
         self.parent.log("Selection edge1 contains all the residues from the edges selected in the first column",
                         timed=False)
         self.parent.log("Selection edge2 contains all the residues from the edges selected in the second column",

main_window.py

@@ -288,7 +288,7 @@ def refresh_sele(self):
         else:
             self.widg.visualize_btn.setText("Execute Ring")
 
-    def visualize(self, selection=None, color=None, int_type=None, edge_set=None):
+    def visualize(self, selection=None, color=None, int_type=None):
         from pymol import stored
 
         if selection:
@@ -332,8 +332,7 @@ def draw():
                 stored.tmp = ""
                 cmd.iterate_state(state=state, selection=obj,
                                   expression='stored.tmp = stored.coords.setdefault("{}/{}/{}"'
-                                             '.format(chain, resi, name), [x,y,z])',
-                                  )
+                                             '.format(chain, resi, name), [x,y,z])')
 
                 interactions_per_type = dict()
 
@@ -343,33 +342,41 @@ def draw():
                     node2 = Node(nodeId2)
                     edge = Edge(node1, node2)
 
-                    try:
-                        freq = conn_freq[intType][edge] * 100
-                    except KeyError:
-                        freq = 0.5 * 100
+                    # Global filters
+                    if node1.id_tuple() not in stored.chain_resi or node2.id_tuple() not in stored.chain_resi:
+                        continue
 
+                    # Apply filters if selection is not present
                     if not selection:
+                        try:
+                            freq = conn_freq[intType][edge] * 100
+                        except KeyError:
+                            freq = 0.5 * 100
+                        # Interchain
                         if self.widg.interchain.isChecked() and node1.chain == node2.chain:
                             continue
+                        # Intrachain
                         if self.widg.intrachain.isChecked() and node1.chain != node2.chain:
                             continue
+                        # Frequency
+                        if not self.widg.min_freq.value() <= freq <= self.widg.max_freq.value():
+                            continue
+                    else:
+                        # Apply filter if selection is present
+                        if not (int_type == intType or int_type == "ALL"):
+                            continue
 
-                    if node1.id_tuple() in stored.chain_resi and node2.id_tuple() in stored.chain_resi \
-                            and (selection or self.widg.min_freq.value() <= freq <= self.widg.max_freq.value()) \
-                            and ((selection and (int_type == intType or int_type == "ALL") and
-                                  edge in edge_set) or not selection):
-                        interactions_per_type.setdefault(intType, [])
-
-                        t = tuple()
-                        if "," in atom1:
-                            t += (atom1,)
-                        else:
-                            t += ("{}/{}/{}".format(node1.chain, str(node1.resi), atom1),)
-                        if "," in atom2:
-                            t += (atom2,)
-                        else:
-                            t += ("{}/{}/{}".format(node2.chain, str(node2.resi), atom2),)
-                        interactions_per_type[intType].append(t)
+                    interactions_per_type.setdefault(intType, [])
+                    t = tuple()
+                    if "," in atom1:
+                        t += (atom1,)
+                    else:
+                        t += ("{}/{}/{}".format(node1.chain, str(node1.resi), atom1),)
+                    if "," in atom2:
+                        t += (atom2,)
+                    else:
+                        t += ("{}/{}/{}".format(node2.chain, str(node2.resi), atom2),)
+                    interactions_per_type[intType].append(t)
 
                 for intType, interactions in interactions_per_type.items():
                     draw_links(interactions,
@@ -386,7 +393,10 @@ def draw():
             self.slider_radius_change()
             self.slider_transp_change()
 
-        cmd.async_(draw)
+        if selection is None:
+            cmd.async_(draw)
+        else:
+            draw()
 
     def create_node_edges_sele(self, model_name, is_sele, obj):
         members = ""

utilities.py

@@ -297,45 +297,35 @@ def draw_links(interactions, color, object_name, coords, state):
 def calculate_correlation(obj, frames, min_presence=0.05, max_presence=0.95, coeff_thresh=0.5, p_thresh=0.3,
                           int_type="HBOND"):
     all_cm = dict()
-    try:
-        if int_type == "ALL":
-            for interaction in intTypeMap.keys():
-                all_cm[interaction] = pd.read_csv('/tmp/ring/md/{}.cm_{}'.format(obj, interaction), sep=' ',
-                                                  header=None)
-        else:
-            all_cm[int_type] = pd.read_csv('/tmp/ring/md/{}.cm_{}'.format(obj, int_type), sep=' ', header=None)
-    except FileNotFoundError:
-        return
+    nodes = []
+    if int_type == "ALL":
+        to_read = intTypeMap.keys()
+    else:
+        to_read = [int_type]
 
-    contacts_sparse = dict()
-    for j in range(1, frames + 1):
-        if int_type == "ALL":
-            interactions = intTypeMap.keys()
-        else:
-            interactions = [int_type]
-        for interaction in interactions:
-            df = all_cm[interaction][all_cm[interaction][0] == j]
-            nodes = df[1]
+    for interaction in to_read:
+        all_cm[interaction] = pd.read_csv('/tmp/ring/md/{}.cm_{}'.format(obj, interaction), sep=' ',
+                                          header=None)
+        if len(nodes) == 0:
+            nodes = all_cm[interaction][all_cm[interaction][0] == 1][1]
             nodes = [Node(x) for x in nodes]
+
+    conn_freq = get_freq(obj)
+    contacts_sparse = dict()
+    for frame in range(0, frames):
+        for interaction in to_read:
+            df = all_cm[interaction][all_cm[interaction][0] == frame + 1]
             df = df.iloc[:, 2:]
             matrix = df.values
             matrix[np.triu_indices(matrix.shape[0])] = 0
-            for i in np.argwhere(matrix > 0):
-                node1 = nodes[i[0]]
-                node2 = nodes[i[1]]
+            for i, j in np.argwhere(matrix > 0):
+                node1 = nodes[i]
+                node2 = nodes[j]
                 edge = Edge(sorted([node1, node2]))
-                contacts_sparse.setdefault(edge, dict())
-                contacts_sparse[edge].setdefault(j - 1, 0)
-                contacts_sparse[edge][j - 1] += 1
-
-    to_pop = []
-    for k, v in contacts_sparse.items():
-        presence = len(v) / frames
-        if not min_presence < presence < max_presence:
-            to_pop.append(k)
-
-    for k in to_pop:
-        contacts_sparse.pop(k)
+                if min_presence < conn_freq[interaction][edge] < max_presence:
+                    contacts_sparse.setdefault(edge, dict())
+                    contacts_sparse[edge].setdefault(frame, 0)
+                    contacts_sparse[edge][frame] += 1
 
     z = np.zeros((len(contacts_sparse), frames))
     for i, contacts_for_frame in enumerate(contacts_sparse.values()):
@@ -345,14 +335,15 @@ def calculate_correlation(obj, frames, min_presence=0.05, max_presence=0.95, coe
     coeffs_matr = np.ones((z.shape[0], z.shape[0])) * np.nan
     p_matr = np.ones((z.shape[0], z.shape[0])) * np.nan
 
-    for i in range(z.shape[0]):
-        for j in range(z.shape[0]):
-            if i != j:
-                corr_coeff, p_val = pearsonr(z[i], z[j])
-                if p_val < p_thresh and (corr_coeff > coeff_thresh or corr_coeff < -coeff_thresh):
-                    coeffs_matr[i, j] = corr_coeff
-                    p_matr[i, j] = p_val
+    indexes = np.triu_indices(z.shape[0], k=1)
+    for i, j in zip(indexes[0], indexes[1]):
 
+        corr_coeff, p_val = pearsonr(z[i], z[j])
+        if p_val < p_thresh and (corr_coeff > coeff_thresh or corr_coeff < -coeff_thresh):
+            coeffs_matr[i, j] = corr_coeff
+            p_matr[i, j] = p_val
+    p_matr[np.tril_indices_from(p_matr)] = p_matr[np.triu_indices_from(p_matr)]
+    coeffs_matr[np.tril_indices_from(coeffs_matr)] = coeffs_matr[np.triu_indices_from(coeffs_matr)]
     return list(contacts_sparse.keys()), coeffs_matr, p_matr
 
 
@@ -476,4 +467,5 @@ def export_network_graph(model):
 
 
 if __name__ == '__main__':
-    export_network_graph('2h9r')
+    # export_network_graph('2h9r')
+    calculate_correlation("trj_cl", 20)