new ladders print

src/atom.py

     bridges = {}
     bridge = {}
     strongest_bridge = {}
-    selected_bridges = []
     for i in range(1,len(residues)-4):
         E_min = 0
         for j in range(i+2,len(residues)-1):
                 if(bridge['res1']+bridge['res2']<E_min):
                     E_min = bridge['res1']+bridge['res2']
                     strongest_bridge = bridge
-                    if strongest_bridge not in selected_bridges:
-                        selected_bridges.append(strongest_bridge)
                     coord_bridge = [i,j]
                     bridge = {}
 
         # finally add the strongest bridge at i and j pos
         if(strongest_bridge):
-            if(len(selected_bridges)>1):
-                bridges[strongest_bridge['i']] = (Bridge(strongest_bridge['btype'],
-                                                         strongest_bridge['ipos'],
-                                                         strongest_bridge['jpos'],
-                                                         [strongest_bridge['i'],
-                                                          strongest_bridge['j']],
-                                                         selected_bridges[-2]['btype'],
-                                                         selected_bridges[-2]['ipos'],
-                                                         selected_bridges[-2]['jpos'],
-                                                         [selected_bridges[-2]['i'],
-                                                          selected_bridges[-2]['j']]))
-                                              
-                bridges[strongest_bridge['j']] = (Bridge(strongest_bridge['btype'],
-                                                         strongest_bridge['ipos'],
-                                                         strongest_bridge['jpos'],
-                                                         [strongest_bridge['i'],
-                                                          strongest_bridge['j']],
-                                                         selected_bridges[-2]['btype'],
-                                                         selected_bridges[-2]['ipos'],
-                                                         selected_bridges[-2]['jpos'],
-                                                         [selected_bridges[-2]['i'],
-                                                          selected_bridges[-2]['j']]))
-            else:
-                bridges[strongest_bridge['i']] = (Bridge(strongest_bridge['btype'],
-                                                         strongest_bridge['ipos'],
-                                                         strongest_bridge['jpos'],
-                                                         [strongest_bridge['i'],
-                                                          strongest_bridge['j']]))
+
+            bridges[strongest_bridge['i']] = (Bridge(strongest_bridge['btype'],
+                                                     strongest_bridge['ipos'],
+                                                     strongest_bridge['jpos'],
+                                                     [strongest_bridge['i'],
+                                                      strongest_bridge['j']]))
                                               
-                bridges[strongest_bridge['j']] = (Bridge(strongest_bridge['btype'],
-                                                         strongest_bridge['ipos'],
-                                                         strongest_bridge['jpos'],
-                                                         [strongest_bridge['i'],
-                                                          strongest_bridge['j']]))
+            bridges[strongest_bridge['j']] = (Bridge(strongest_bridge['btype'],
+                                                     strongest_bridge['ipos'],
+                                                     strongest_bridge['jpos'],
+                                                     [strongest_bridge['i'],
+                                                      strongest_bridge['j']]))
     if(len(bridges)>0):
         return(bridges)
     else:
     links = []
     for bridge in ladd_1['bridges']:
         if bridge.res_partner in res_list(ladd_2):
-            # return([ladd_1['i'], ladd_1['j'], bridge.i, bridge.j,
-            #         ladd_2['i'], ladd_2['j']])
             return ladd_2
 
     return False
 
+def connected_ladders2(ladd_1, ladd_2):
+    links = []
+    for bridge in ladd_1['bridges']:
+        if bridge.res_partner in res_list(ladd_2):
+            return([ladd_1['i'], ladd_1['j'], bridge.i, bridge.j,
+                    ladd_2['i'], ladd_2['j']])
+            #return ladd_2
+
+    return False
+
+
 def get_sheets(ladders):
     """
     Bridges between ladders.
     sheets = {}    
     for ladder in ladders:
         for ladd2 in ladders:
-           if connected_ladders(ladders[ladder], ladders[ladd2]):
-               pass
-               print("ladder",ladders[ladder]['i'], ladders[ladder]['j'],"bridge",bridge.i, bridge.j,
-                    "ladder 2",ladders[ladd2]['i'], ladders[ladd2]['j'])
+            if connected_ladders(ladders[ladder], ladders[ladd2]):
+                bridge_i = connected_ladders2(ladders[ladder], ladders[ladd2])[2]
+                bridge_j = connected_ladders2(ladders[ladder], ladders[ladd2])[3]
+                print("ladder",ladders[ladder]['i'], ladders[ladder]['j'],"bridge",bridge_i, bridge_j,
+                      "ladder 2",ladders[ladd2]['i'], ladders[ladd2]['j'])
 
                
 def res_list(ladder):
     # TODO : method in ladder class
     l=[]
-    for i in range(ladder['start'], ladder['end']):
+    for i in range(ladder['i'], ladder['j']):
         l.append(i)
     return(l)
-                   
-def get_bends(residues):
-    bends = {}
-    for i in range(2,len(residues)-2):
-        angle = math.degrees(vector_angles(vectors_substr(position_vector(residues[i].atoms["CA"].coords),
-                                                          position_vector(residues[i-2].atoms["CA"].coords)),
-                                           vectors_substr(position_vector(residues[i+2].atoms["CA"].coords),
-                                                          position_vector(residues[i].atoms["CA"].coords))))
-        if(angle>70):
-            print("angle", residues[i].resid, angle)
-            bends[residues[i].resid] = angle
-    return(bends)
-
-def get_chirality(residues):
-
-    for i in range(1,len(residues)-2):
-        chirality = {}
-        angle = calc_dihedral(residues[i-1].atoms["CA"].coords,
-                              residues[i].atoms["CA"].coords,
-                              residues[i+1].atoms["CA"].coords,
-                              residues[i+2].atoms["CA"].coords)
-        
-        if(angle>0 and angle<=180):
-            sign="+"
-            print("chirality", residues[i].resid, "+", angle)
-            
-        if(angle<=0 and angle > -180):
-            sign="-"
-            print("chirality", residues[i].resid, "-", angle)
-            
-        chirality[residues[i].resid] = sign
-        
-    return chirality
-
-
-def get_phi_psi(residues):
-    for i in range(len(residues)):
-        if(i==0):
-            phi = 360.0
-        else:
-            phi = calc_dihedral(residues[i-1].atoms["C"].coords,
-                                residues[i].atoms["N"].coords,
-                                residues[i].atoms["CA"].coords,
-                                residues[i].atoms["C"].coords)
-        if(i==len(residues)-1):
-            psi = 360.0
-        else:
-            psi = calc_dihedral(residues[i].atoms["N"].coords,
-                                residues[i].atoms["CA"].coords,
-                                residues[i].atoms["C"].coords,
-                                residues[i+1].atoms["N"].coords)
-
-        print("ANGLES", i, phi, psi)
-
-def get_TCO(res1, res2):
-    CO_res1 = vector_from_pos(res1.atoms["C"].coords,
-                              res1.atoms["O"].coords)
-    CO_res2 = vector_from_pos(res2.atoms["C"].coords,
-                              res2.atoms["O"].coords)
-    angle = vector_angles(CO_res1, CO_res2)
-    return(math.cos(angle))
-
 
 def build_turns_patterns(residues):
     turns_3 = {}

src/dssp.py

     turn_3 = print_turn_pattern(residues, res, turns[0])
     turn_4 = print_turn_pattern(residues, res, turns[1])
     turn_5 = print_turn_pattern(residues, res, turns[2])
-
     helix_3 = print_helix_pattern(residues, res, helix[0])
     helix_4 = print_helix_pattern(residues, res, helix[1])
     helix_5 = print_helix_pattern(residues, res, helix[2])
            round(alpha, 1), round(phi, 1), round(psi,1), round(x_ca,1), round(y_ca,1), round(z_ca,1))
 
 
-for bridge in bridges:
-    print(bridges[bridge].i, bridges[bridge].j)
+for ladd1 in ladders:
+    ladd_1 = ladders[ladd1]
+    for ladd2 in ladders:
+        ladd_2 = ladders[ladd2]
+        for bridge in ladd_1['bridges']:
+            if bridge.j in res_list(ladd_2):  
+                print("ladder", ladd_1['i'],"-",ladd_1['j'], "|", bridge.i, "...", bridge.j, "| ladder", ladd_2['i'], ladd_2['j'])
+
+# for ind, sheet in sheets.items():
+#     print(ind, sheet)
+#     for ladder in sheet:
+#         print(ladder['start'], ladder['end'])

src/structure.py

                         
 class Bridge(Structure):
 
-    def __init__(self, bridge_type, res_num, res_partner, indices,
-                 second_bridge_type=None, second_resnum=None,
-                 second_res_partner=None, second_indices=None):
+    def __init__(self, bridge_type, res_num, res_partner, indices):
         self.bridge_type = bridge_type
         self.res_num = res_num
         self.res_partner = res_partner
         Structure.res = res_num
         self.i = indices[0]
         self.j = indices[1]
-        self.second_bridge_type = second_bridge_type
-        self.second_resnum = second_resnum
-        self.second_res_partner = second_res_partner
-        self.second_indices = second_indices
 
 class Helix(Structure):