Source Code for Module csb.apps.bfit

  1  """ 
  2  Python application for robust structure superposition of two structures. 
  3  bfit models non-rigid displacements in protein ensembles with outlier-tolerant 
  4  probability distributions. 
  5  """ 
  6  import numpy 
  7   
  8  import csb.apps 
  9  import csb.bio.utils 
 10   
 11  from csb.bio.io.wwpdb import LegacyStructureParser 
 12  from csb.bio.sequence import SequenceAlignment 
 13   
 14   
 15 -class ExitCodes(csb.apps.ExitCodes): 
 16      IO_ERROR = 2 
 17      INPUT_ERROR = 3 
 18   
 19 -class AppRunner(csb.apps.AppRunner): 
 20   
 21      @property 
 22 -    def target(self): 
 23          return BFitApp 
 24   
 25 -    def command_line(self): 
 26           
 27          cmd = csb.apps.ArgHandler(self.program, __doc__) 
 28   
 29          # Input structures 
 30          cmd.add_positional_argument('pdb1', str, 
 31                                      'full path to the first structure') 
 32   
 33          cmd.add_positional_argument('pdb2', str, 
 34                                      'full path to the second structure') 
 35   
 36          # Optional arguments  
 37          cmd.add_scalar_option('chain1', 'c', str, 
 38                                'Chain of the first structure', 
 39                                default='A') 
 40   
 41          cmd.add_scalar_option('chain2', 'd', str, 
 42                                'Chain of the second structure', 
 43                                default='A') 
 44           
 45          cmd.add_scalar_option('scalemixture', 's', str, 
 46                                'Scale mixture distribution', 
 47                                default='student', 
 48                                choices=['student', 'k']) 
 49   
 50           
 51          cmd.add_scalar_option('alignment', 'a', str, 
 52                                'Alignment in fasta format defining equivalent positions\n' 
 53                                + 'Assumes that chain1 is the first sequence of ' 
 54                                + 'the alignment and chain2 the second sequence') 
 55   
 56          cmd.add_scalar_option('outfile', 'o', str, 
 57                                'file to which the rotated second ' +  
 58                                'structure will be written', 
 59                                default='bfit.pdb') 
 60   
 61          cmd.add_scalar_option('niter', 'n', int, 
 62                                'Number of optimization steps', 
 63                                default=200) 
 64   
 65          cmd.add_boolean_option('em', None, 
 66                                 'Use the EM algorithm for optimsation', 
 67                                 default = False) 
 68   
 69          return cmd 
 70   
 71   
 72   
 73 -class BFitApp(csb.apps.Application): 
 74      """ 
 75      Python application for robust structure superposition of two protein structures 
 76      """ 
 77   
 78 -    def main(self): 
 79          try: 
 80              parser = LegacyStructureParser(self.args.pdb1) 
 81              r = parser.parse() 
 82   
 83              parser = LegacyStructureParser(self.args.pdb2) 
 84              m = parser.parse() 
 85          except IOError as e: 
 86              self.exit('PDB file parsing failed\n' + str(e.value), ExitCodes.IO_ERROR) 
 87   
 88          X = numpy.array(r[self.args.chain1].get_coordinates(['CA'], True)) 
 89          Y = numpy.array(m[self.args.chain2].get_coordinates(['CA'], True)) 
 90   
 91          if self.args.alignment is not None: 
 92              align = SequenceAlignment.parse(file(self.args.alignment).read()) 
 93              align = align[:2, :] 
 94               
 95              matches = [] 
 96              for i in range(1, align.length + 1): 
 97                  if not align.gap_at(i): 
 98                      matches.append([align.columns[i][0].rank - 1, 
 99                                      align.columns[i][1].rank - 1]) 
100              matches = numpy.array(matches) 
101              X = X[matches[:, 0], :] 
102              Y = Y[matches[:, 1], :] 
103   
104           
105          if len(X) != len(Y): 
106              self.exit('Structures are of different lengths,' +  
107                        ' please specify an alignment', 
108                        ExitCodes.INPUT_ERROR) 
109   
110          R, t = csb.bio.utils.bfit(X, Y, self.args.niter, 
111                  self.args.scalemixture, self.args.em) 
112   
113          m.transform(R, t) 
114          m.to_pdb(self.args.outfile) 
115           
116   
117 -def main(): 
118      AppRunner().run() 
119       
120       
121  if __name__ == '__main__': 
122      main() 
123