Cleaning commented artefacts

src/chem.py

 import math
-#from structure import *
 from geom import *
 
 class Atom:
                     if(self.h_bond(residues[i+j])<-0.5):
                         k = j
         if k != 0:    
-            #print(k,"TURN", residues[i].resid, residues[i+k].resid)
             return Turn(k,residues[i].resid)
 
         return False
     def get_bends(self, residues):
         i = residues.index(self)
         if i >=2 and i <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))))
+            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):
                 return [angle, 'S']
             return [angle, '']
         else:
             return [360.0, '']
 
-    def get_bridges(self, residues):
-        bridges = {}
-        bridge = {}
-        strongest_bridge = {}
-        i = residues.index(self)
-        if(i >= 1 and i < len(residues)-4):
-            E_min = 0
-            for j in range(i+2,len(residues)-1):
-                # select triplet with the minimal energy 
-
-                if(residues[i-1].h_bond(residues[j])<-0.5
-                   and residues[j].h_bond(residues[i+1])<-0.5):
-                    bridge = {'res1':residues[i-1].h_bond(residues[j]),
-                              'res2':residues[j].h_bond(residues[i+1]),
-                              'ipos':residues[i].resid,
-                              'jpos':residues[j].resid,
-                              'btype':"para"}
-
-                if(residues[j-1].h_bond(residues[i])<-0.5
-                   and residues[i].h_bond(residues[j+1])<-0.5):
-                    bridge = {'res1':residues[j-1].h_bond(residues[i]),
-                              'res2':residues[i].h_bond(residues[j+1]),
-                              'ipos':residues[i].resid,
-                              'jpos':residues[j].resid,
-                              'btype':"para"}
-
-                if(residues[i].h_bond(residues[j])<-0.5
-                   and residues[j].h_bond(residues[i])<-0.5):
-                    bridge = {'res1':residues[i].h_bond(residues[j]),
-                              'res2':residues[j].h_bond(residues[i]),
-                              'ipos':residues[i].resid,
-                              'jpos':residues[j].resid,
-                              'btype':"anti"}
-
-                if(residues[i-1].h_bond(residues[j+1])<-0.5
-                   and residues[j-1].h_bond(residues[i+1])<-0.5):
-                    bridge = {'res1':residues[i-1].h_bond(residues[j+1]),
-                              'res2':residues[j-1].h_bond(residues[i+1]),
-                              'ipos':residues[i].resid,
-                              'jpos':residues[j].resid,
-                              'btype':"anti"}
-
-                if(bridge):
-                    if(bridge['res1']+bridge['res2']<E_min):
-                        E_min = bridge['res1']+bridge['res2']
-                        strongest_bridge = bridge
-                        bridge = {}
-                        coord_bridge = [i,j]
-            # finally add the strongest bridge at i and j pos
-            if(strongest_bridge):
-                bridges[coord_bridge[0]] = (Bridge(strongest_bridge['btype'],
-                                                   strongest_bridge['ipos'],
-                                                   strongest_bridge['jpos']))
-                
-                bridges[coord_bridge[1]] = (Bridge(strongest_bridge['btype'],
-                                                   strongest_bridge['jpos'],
-                                                   strongest_bridge['ipos']))
-        if(len(bridges)>0):
-            return(bridges[coord_bridge[0]])
-        else:
-            return(False)
-
     def get_helix(self, residues):
         """
         Return if there is an helix at a given residue,
             return False
         
         if(self.get_turns(residues) and residues[i-1].get_turns(residues)):
-            #print(self.get_turns(residues).turn_type,"- HELIX at", residues[i].indice)
             return(self.get_turns(residues).turn_type, residues[i].indice)
         return(False)
 
     def get_ladder(self, residues):
-        #ladders = {}
         i = residues.index(self)
         if i != 0:
             if self.get_bridges(residues):
                     local_bridge = self.get_bridges(residues)
                     consec_bridge = residues[i-1].get_bridges(residues)
                     if local_bridge.bridge_type == consec_bridge.bridge_type:
-                        #print("ladder", consec_bridge.res_num, local_bridge.res_num)
                         ladder = {'start':consec_bridge.res_num,
                                   'end':local_bridge.res_num,
                                   'bridges':[consec_bridge, local_bridge]}
         E_min = 0
         for j in range(i+2,len(residues)-1):
             # select triplet with the minimal energy 
-            
             if(residues[i-1].h_bond(residues[j])<-0.5
                and residues[j].h_bond(residues[i+1])<-0.5):
                 bridge = {'res1':residues[i-1].h_bond(residues[j]),
 
         # finally add the strongest bridge at i and j pos
         if(strongest_bridge):
-
             bridges[strongest_bridge['i']] = (Bridge(strongest_bridge['btype'],
                                                      strongest_bridge['ipos'],
                                                      strongest_bridge['jpos'],
                                                      [strongest_bridge['i'],
-                                                      strongest_bridge['j']]))
-                                              
+                                                      strongest_bridge['j']]))                                        
             bridges[strongest_bridge['j']] = (Bridge(strongest_bridge['btype'],
                                                      strongest_bridge['ipos'],
                                                      strongest_bridge['jpos'],
                 temp_bridges.append(bridges[i+k])
                 k+=1
         if k>1:
-            #print("ladder", bridges[i].res_num, bridges[i+k-1].res_num)
             ladders[i] = {'start':bridges[i].res_num,
                           'end':bridges[i+k-1].res_num,
                           'bridges':temp_bridges,
     for bridge in ladd_1['bridges']:
         if bridge.res_partner in res_list(ladd_2):
             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.
     """
     ladds = [ elem for elem in ladders.values() ]
     sheets = {}
-
     corresp = {}
     for ladd1 in ladds:
         for ladd2 in ladds:
                     corresp[ladd2['i']] = corresp[ladd1['i']]
                 elif ladd1 not in corresp_list and ladd2 in corresp_list:
                     sheets[corresp[ladd2['i']]].append(ladd1)
-                    corresp[ladd1['i']] = corresp[ladd2['i']]
-                    
+                    corresp[ladd1['i']] = corresp[ladd2['i']]                   
     return sheets
-
-def get_sheets2(ladders):
-    """
-    Bridges between ladders.
-    Check if 1 bridge between one ladder and one or more other ladders.
-    Iterate over all residues of one ladder and check if bridge with other residues
-    of the other ladders.
-    """
-    sheets = {}    
-    for ladder in ladders:
-        for ladd2 in ladders:
-            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['i'], ladder['j']):
         l.append(i)
         if(helix):
             helix_type = residues[i].get_helix(residues)[0]
             helix_pos = residues[i].get_helix(residues)[1]
-            #print("TYPE", helix_type)
             for k in range(helix_type):
                 if helix_type == 3:
                     helix_3[i+1+k] = "G"
                     helix_4[i+1+k] = "H"
                 if helix_type == 5:
                     helix_5[i+1+k] = "I"
-        #print(helix_3)
     return[helix_3, helix_4, helix_5]
 
 def print_helix_pattern(residues, res, helix):
             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'])
+                    print("ladder", ladd_1['i'],"-", ladd_1['j'], "|",
+                          bridge.i, "...", bridge.j, "| ladder",
+                          ladd_2['i'], ladd_2['j'])
 

src/pdb.py

         self.rawLines = self.get_content(filename)
         self.metadata = self.get_header()
         self.get_atoms(filename)
-        # for elem in self.metadata : 
-        #     print(self.metadata[elem], end="")
-        
+