hdiff output

r31900/dijkstra_test.py 2017-02-10 15:30:15.698609198 +0000 r31899/dijkstra_test.py 2017-02-10 15:30:16.150615035 +0000
  7: def duplicate_test(graph,min1,min2):  7: def duplicate_test(graph,min1,min2):
  8:     return min1 in G.neighbors(min2)  8:     return min1 in G.neighbors(min2)
  9: if len(sys.argv) < 4:  9: if len(sys.argv) < 4:
 10:    print 'dijkstra_test.py minA minBi npairs ([True/False] for debugging)' 10:    print 'dijkstra_test.py minA minBi npairs ([True/False] for debugging)'
 11:    exit() 11:    exit()
 12:     12:    
 13: A = int(sys.argv[1]) 13: A = int(sys.argv[1])
 14: B = int(sys.argv[2]) 14: B = int(sys.argv[2])
 15: npairs = int(sys.argv[3]) 15: npairs = int(sys.argv[3])
 16: if len(sys.argv) == 5:  16: if len(sys.argv) == 5: 
 17:    if sys.argv[4] == 'True': 17:    debug = sys.argv[4]
 18:       debug = True 
 19:       print 'Debugging is on' 
 20:    else: 
 21:       debug = False 
 22: else: 18: else:
 23:    debug = False 19:    debug = False
 24:  20: 
 25: #default for input files 21: #default for input files
 26: min_f = "min.data" 22: min_f = "min.data"
 27: ts_f = "ts.data" 23: ts_f = "ts.data"
 28: paird_f = "pairdist" 24: paird_f = "pairdist"
 29: pairl_f = "pairlist" 25: pairl_f = "pairlist"
 30:  26: 
 31: print 27: print


r31900/genrigid_input.py 2017-02-10 15:30:15.474606304 +0000 r31899/genrigid_input.py 2017-02-10 15:30:15.930612194 +0000
798:                     if int(res[i]) <= mol.num_res():798:                     if int(res[i]) <= mol.num_res():
799:                         local_res.append(int(res[i]))799:                         local_res.append(int(res[i]))
800:                         log_res += res[i] + ' '800:                         log_res += res[i] + ' '
801:                         i += 1801:                         i += 1
802:                 except ValueError:802:                 except ValueError:
803:                     i += 1803:                     i += 1
804:         log.append('Residues entered to be removed from local rigidification: ' + log_res + "\n")804:         log.append('Residues entered to be removed from local rigidification: ' + log_res + "\n")
805:     return (unfrozen_res, local_res, log)805:     return (unfrozen_res, local_res, log)
806: 806: 
807: 807: 
808: ###FUNCTIONS FOR GROUPROTATION FILE ################################################################################### 
809: def get_prob_amb(): 
810:     while 1: 
811:         inp_p = 'Probability: ' 
812:         inp_a = 'Amplitude: ' 
813:         try: 
814:             probability = float(inp_p) 
815:             amplitude = float(inp_a) 
816:             if (probability > 1.0) or (probability < 0.0): 
817:                 print 'Invalid probability' 
818:             else: 
819:                 break 
820:         except ValueError: 
821:             print 'Both values need to be numbers' 
822:     return (probability,amplitude) 
823:  
824:  
825: ###VARIABLE DEFINITION ################################################################################################808: ###VARIABLE DEFINITION ################################################################################################
826: atom_dic = {}  #dictionary containing all information sorted by atom number:809: atom_dic = {}  #dictionary containing all information sorted by atom number:
827:                #the information is in a tuple: (atomname, residue name, residue number, x, y, z)810:                #the information is in a tuple: (atomname, residue name, residue number, x, y, z)
828: res_dic = {}  #dictionary containing all atoms per residue sorted by residue number811: res_dic = {}  #dictionary containing all atoms per residue sorted by residue number
829: res_atomistic = []  #residue list that are treated fully atomistic812: res_atomistic = []  #residue list that are treated fully atomistic
830: res_local = []  #residue list that are treated locally rigid813: res_local = []  #residue list that are treated locally rigid
831: res_frozen = []  #residue list that are treated fully rigid814: res_frozen = []  #residue list that are treated fully rigid
832: atoms_used = []  #atoms used in rigid bodies, prevents double usage!815: atoms_used = []  #atoms used in rigid bodies, prevents double usage!
833: groups = {}  #dictionary of rigid groups816: groups = {}  #dictionary of rigid groups
834: groups_local = {}817: groups_local = {}
1373: for group_local in range(1, len(groups_local.keys()) + 1):1356: for group_local in range(1, len(groups_local.keys()) + 1):
1374:     string = ''1357:     string = ''
1375:     counter = 01358:     counter = 0
1376:     for atom in groups_local[group_local][2:]:1359:     for atom in groups_local[group_local][2:]:
1377:         string += str(atom) + "\n"1360:         string += str(atom) + "\n"
1378:         counter += 11361:         counter += 1
1379:         natom_rbody += 11362:         natom_rbody += 1
1380:     groups_file.write('GROUP ' + str(counter) + "\n" + string)1363:     groups_file.write('GROUP ' + str(counter) + "\n" + string)
1381: groups_file.close()1364: groups_file.close()
1382: 1365: 
1383: ### FINISH LOG FILE FOR RIGID BODIES###1366: ### FINISH LOG FILE ###
1384: check_file.write("\n" + "\n" + 'Number of rigid bodies: ' + str(len(groups.keys()) + len(groups_local.keys())))1367: checkfile.write("\n" + "\n" + 'Number of rigid bodies: ' + str(len(groups.keys()) + len(groups_local.keys())))
1385: check_file.write("\n" + 'Degrees of freedom: ' + str(3 * natom_rbody + 6* (len(groups.keys()) + len(groups_local.keys()))))1368: checkfile.write("\n" + 'Degrees of freedom: ' + str(3 * natom_rbody + 6* (len(groups.keys()) + len(groups_local.keys()))))
1386:  
1387:  
1388:  
1389: ### CREATING GROUP ROTATION FILES ##################################################################################### 
1390: print '' 
1391: group_rot_t = raw_input('Create group rotation file (y/n)? ') 
1392: if group_rot_t in ['y', 'yes']: 
1393:     check_file.write("\n" + "\n" + 'Create group rotation file' + "\n") 
1394:     while 1: 
1395:         prob_uni_inp = raw_input('Uniform selection probability (suggested: 0.025): ') 
1396:         try: 
1397:             prob_uni = float(prob_uni_inp) 
1398:             if prob_uni > 0.1: 
1399:                 print 'This is a large probability (values recommended: 0.01 to 0.1).' 
1400:                 prob_uni_check = raw_input(' Continue with the selected value (y/n)? ') 
1401:                 if prob_uni_check in ['y','yes']: 
1402:                     break 
1403:             elif prob_uni < 0.01: 
1404:                 print 'This is a small probability (values recommended: 0.01 to 0.1).' 
1405:                 prob_uni_check = raw_input(' Continue with the selected value (y/n)? ') 
1406:                 if prob_uni_check in ['y','yes']: 
1407:                     break 
1408:             else: 
1409:                 break 
1410:         except ValueError: 
1411:             print 'Input needs to be a float' 
1412:     check_file.write('Selection probability: ' + str(prob_uni) + "\n") 
1413:     while 1: 
1414:         grouprot_reg_inp = raw_input('Create the group rotation file for the all atom region (1), the locally rigidified region (2), or both regions (3)? ') 
1415:         try: 
1416:             group_reg = int(grouprot_reg_inp) 
1417:             if group_reg == 1: 
1418:                 grot_res = res_atomistic 
1419:                 check_file.write('Only all atom region' + "\n") 
1420:                 break 
1421:             elif group_reg == 2: 
1422:                 grot_res = res_local 
1423:                 check_file.write('Only local rigid region' + "\n") 
1424:                 break 
1425:             elif group_reg == 3: 
1426:                 grot_res = res_atomistic + res_local 
1427:                 check_file.write('Local rigid and all atom regions' + "\n") 
1428:                 break 
1429:             else: 
1430:                 print 'Please choose one of the options.' 
1431:         except ValueError: 
1432:             print 'Please choose one of the options.' 
1433:  
1434:     group_rotations = [False , False , False , False , False] 
1435:     def_values = [True , True , True , True ,True] 
1436:     #default amplitudes (copied from original Fortran script) 
1437:     amp_dic = {'ALA' : (1.0), 
1438:                'ASN' : (0.5 , 1.0), 
1439:                'ARG' : (0.2 , 0.3 , 0.5), 
1440:                'ASP' : (0.5 , 1.0), 
1441:                'CYS' : (1.0), 
1442:                'GLN' : (0.3 , 0.5 , 1.0), 
1443:                'GLU' : (0.3 , 0.5 , 1.0), 
1444:                'HIS' : (0.3 , 0.5), 
1445:                'HIE' : (0.3 , 0.5), 
1446:                'HIP' : (0.3 , 0.5), 
1447:                'HIS' : (0.3 , 0.5), 
1448:                'HID' : (0.3 , 0.5), 
1449:                'ILE' : (0.5 , 1.0), 
1450:                'LEU' : (0.5 , 1.0), 
1451:                'LYS' : (0.2 , 0.3 , 0.5), 
1452:                'MET' : (0.5 , 0.7), 
1453:                'PHE' : (0.3 , 0.5), 
1454:                'SER' : (1.0), 
1455:                'THR' : (1.0), 
1456:                'TRP' : (0.3 , 0.4), 
1457:                'TYR' : (0.3 , 0.5), 
1458:                'VAL' : (1.0), 
1459:                'AMB0': (0.1)     #default for all non residue specific rotations 
1460:                } 
1461:  
1462:     #number: [name, ax_atom1, ax_atom2, natom, amp, prob, [atom1, atom2, ...]] 
1463:     grot_dic = {} 
1464:  
1465:     N_CA = raw_input('Group rotations of side chains about N-CA axis (not PRO) (y/n)? ') 
1466:     if N_CA in ['y' , 'yes']: 
1467:         group_rotations[0] = True 
1468:         check_file.write('Group rotation for N - CA' + "\n") 
1469:         N_CA_def = raw_input('Use default values (y/n)? ') 
1470:         if N_CA_def not in ['y' , 'yes']: 
1471:             def_values[0] = False 
1472:     C_CA = raw_input('Group rotations of side chains about C-CA axis (not PRO) (y/n)? ') 
1473:     if C_CA in ['y' , 'yes']: 
1474:         check_file.write('Group rotation for C - CA' + "\n") 
1475:         group_rotations[1] = True 
1476:         C_CA_def = raw_input('Use default values (y/n)? ') 
1477:         if C_CA_def not in ['y' , 'yes']: 
1478:             def_values[1] = False 
1479:     CA_CB = raw_input('Group rotations of side chains about CA-CB axis (not ALA, GLY, PRO) (y/n)? ') 
1480:     if CA_CB in ['y' , 'yes']: 
1481:         check_file.write('Group rotation for CA - CB' + "\n") 
1482:         group_rotations[2] = True 
1483:         CA_CB_def = raw_input('Use default values (y/n)? ') 
1484:         if CA_CB_def not in ['y' , 'yes']: 
1485:             def_values[2] = False 
1486:     CB_CG = raw_input('Group rotations of side chains about CB-CG axis (not ALA, GLY, PRO, SER, CYS, THR, VAL) (y/n)? ') 
1487:     if CB_CG in ['y' , 'yes']: 
1488:         check_file.write('Group rotation for CB - CG' + "\n") 
1489:         group_rotations[3] = True 
1490:         CB_CG_def = raw_input('Use default values (y/n)? ') 
1491:         if CB_CG_def not in ['y' , 'yes']: 
1492:             def_values[3] = False 
1493:     CG_CD = raw_input('Group rotations of side chains about CG-CD axis (only ARG, LYS, GLU, GLN) (y/n)? ') 
1494:     if CG_CD in ['y' , 'yes']: 
1495:         check_file.write('Group rotation for CG - CD' + "\n") 
1496:         group_rotations[4] = True 
1497:         CG_CD_def = raw_input('Use default values (y/n)? ') 
1498:         if CG_CD_def not in ['y' , 'yes']: 
1499:             def_values[4] = False 
1500:  
1501:     for res_gr in grot_res: 
1502:         gr_res_name = loaded_mol.get_residue_name(res_gr) 
1503:         if group_rotations[0] and gr_res_name not in ['PRO']: 
1504:             #N-CA rotation 
1505:             if def_values[0]: 
1506:                 prob = prob_uni 
1507:                 amp = 0.1 #use default amplitude 
1508:             else: 
1509:                 prob,amp = get_prob_amb() 
1510:             ax1 = loaded_mol.get_atom_id_from_name('N',res_gr) 
1511:             ax2 = loaded_mol.get_atom_id_from_name('CA',res_gr) 
1512:             gr_name = 'NCA'+str(res_gr) 
1513:             gr_atoms = [] 
1514:             for gr_atom in loaded_mol.get_atom_list(res_gr): 
1515:                 if atom_dic[gr_atom][0] not in ['N','H','C','CA','HA','O','OXT','H1','H2','H3']: 
1516:                     gr_atoms.append(gr_atom) 
1517:             grot_dic[len(grot_dic)+1] = [gr_name, ax1, ax2, len(gr_atoms), amp, prob, gr_atoms] 
1518:  
1519:         if group_rotations[1] and gr_res_name not in ['PRO']: 
1520:             #C-CA rotation 
1521:             if def_values[1]: 
1522:                 prob = prob_uni 
1523:                 amp = 0.1 #use default amplitude 
1524:             else: 
1525:                 prob,amp = get_prob_amb() 
1526:             ax1 = loaded_mol.get_atom_id_from_name('C',res_gr) 
1527:             ax2 = loaded_mol.get_atom_id_from_name('CA',res_gr) 
1528:             gr_name ='CCA'+str(res_gr) 
1529:             gr_atoms = [] 
1530:             for gr_atom in loaded_mol.get_atom_list(res_gr): 
1531:                 if atom_dic[gr_atom][0] not in ['N','H','C','CA','HA','O','OXT','H1','H2','H3']: 
1532:                     gr_atoms.append(gr_atom) 
1533:             grot_dic[len(grot_dic)+1] = [gr_name, ax1, ax2, len(gr_atoms), amp, prob, gr_atoms] 
1534:  
1535:         if group_rotations[2] and gr_res_name not in ['PRO','ALA','GLY']: 
1536:             #CA-CB rotation 
1537:             if def_values[2]: 
1538:                 prob = prob_uni 
1539:                 try: 
1540:                     amp = amp_dic[gr_res_name][0] #use default amplitude 
1541:                 except KeyError: 
1542:                     print 'No default data available for ' + gr_res_name 
1543:                     prob,amp = get_prob_amb() 
1544:             else: 
1545:                 prob,amp = get_prob_amb() 
1546:             ax1 = loaded_mol.get_atom_id_from_name('CA',res_gr) 
1547:             ax2 = loaded_mol.get_atom_id_from_name('CB',res_gr) 
1548:             gr_name = 'CACB'+str(res_gr) 
1549:             gr_atoms = [] 
1550:             for gr_atom in loaded_mol.get_atom_list(res_gr): 
1551:                 if atom_dic[gr_atom][0] not in ['N','H','C','CA','HA','CB','O','OXT','H1','H2','H3']: 
1552:                     gr_atoms.append(gr_atom) 
1553:             grot_dic[len(grot_dic)+1] = [gr_name, ax1, ax2, len(gr_atoms), amp, prob, gr_atoms] 
1554:  
1555:         if group_rotations[3] and gr_res_name not in ['PRO','ALA','GLY','SER','CYS','THR','VAL']: 
1556:             #CB-CG rotation 
1557:             if def_values[3]: 
1558:                 prob = prob_uni 
1559:                 try: 
1560:                     amp = amp_dic[gr_res_name][1] #use default amplitude 
1561:                 except KeyError: 
1562:                     print 'No default data available for ' + gr_res_name 
1563:                     prob,amp = get_prob_amb() 
1564:             else: 
1565:                 prob,amp = get_prob_amb() 
1566:             ax1 = loaded_mol.get_atom_id_from_name('CB',res_gr) 
1567:             ax2 = loaded_mol.get_atom_id_from_name('CG',res_gr) 
1568:             gr_name = 'CBCG'+str(res_gr) 
1569:             gr_atoms = [] 
1570:             for gr_atom in loaded_mol.get_atom_list(res_gr): 
1571:                 if atom_dic[gr_atom][0] not in ['N','H','C','CA','HA','CB','CG','HB','HB1','HB2','HB3','O','OXT','H1','H2','H3']: 
1572:                     gr_atoms.append(gr_atom) 
1573:             grot_dic[len(grot_dic)+1] = [gr_name, ax1, ax2, len(gr_atoms), amp, prob, gr_atoms] 
1574:  
1575:         if group_rotations[4] and gr_res_name in ['ARG','LYS','GLU','GLN']: 
1576:             #CG-CD rotation 
1577:             if def_values[4]: 
1578:                 prob = prob_uni 
1579:                 try: 
1580:                     amp = amp_dic[gr_res_name][2] #use default amplitude 
1581:                 except KeyError: 
1582:                     print 'No default data available for ' + gr_res_name 
1583:                     prob,amp = get_prob_amb() 
1584:             else: 
1585:                 prob,amp = get_prob_amb() 
1586:             ax1 = loaded_mol.get_atom_id_from_name('CG',res_gr) 
1587:             ax2 = loaded_mol.get_atom_id_from_name('CD',res_gr) 
1588:             gr_name = 'CGCD'+str(res_gr) 
1589:             gr_atoms = [] 
1590:             atom_exc = ['N','H','C','CA','HA','CB','CG','HB','HB1','HB2','HB3','O','OXT','H1','H2','H3','CD','HG1','HG2','HG11','HG12','HG13','HG21','HG22','HG23'] 
1591:             for gr_atom in loaded_mol.get_atom_list(res_gr): 
1592:                 if atom_dic[gr_atom][0] not in atom_exc: 
1593:                     gr_atoms.append(gr_atom) 
1594:             grot_dic[len(grot_dic)+1] = [gr_name, ax1, ax2, len(gr_atoms), amp, prob, gr_atoms] 
1595:  
1596:     #user defined groups 
1597:     gr_user_inp = raw_input('Add user defined rotational groups? ') 
1598:     if gr_user_inp in ['y','yes']: 
1599:         gr_user_t = True 
1600:     else: 
1601:         gr_user_t = False 
1602:     useri = 1 
1603:     while gr_user_t: 
1604:         print 'No tests for valid groups!' 
1605:         gr_name = 'USERD' + str(useri) 
1606:         try: 
1607:             ax1 = int(raw_input('Atom number for axis1: ')) 
1608:             ax2 = int(raw_input('Atom number for axis2: ')) 
1609:             prob,amp = get_prob_amb() 
1610:             gr_atoms = [int(x) for x in split(raw_input('List of atoms in group separated by spaces: '))] 
1611:         except: 
1612:             print 'Invalid input' 
1613:         else: 
1614:             grot_dic[len(grot_dic)+1] = [gr_name, ax1, ax2, len(gr_atoms), amp, prob, gr_atoms] 
1615:         finally: 
1616:             gr_user_inp = raw_input('Add user defined rotational group? ') 
1617:             if gr_user_inp in ['y','yes']: 
1618:                 gr_user_t = True 
1619:             else: 
1620:                 gr_user_t = False 
1621:  
1622:     #write output for group rotation files 
1623:     groups_file = open('atomgroups', 'w') 
1624:     for group in range(1, len(grot_dic.keys()) + 1): 
1625:         string = 'GROUP ' + grot_dic[group][0] + ' ' + str(grot_dic[group][1]) + ' ' + str(grot_dic[group][2]) 
1626:         string += ' ' + str(grot_dic[group][3]) + ' ' + str(grot_dic[group][4]) + ' ' + str(grot_dic[group][5]) + "\n" 
1627:         for atom in grot_dic[group][6]: 
1628:             string += str(atom) + "\n" 
1629:         groups_file.write(string) 
1630:  
1631: check_file.close()1369: check_file.close()
1632: 1370: 
1633: ### Writing in file parmed.py to exclude interactions ####1371: ### Writing in file parmed.py to exclude interactions ####
1634: parmed_in = open('parmed_in', "w")1372: parmed_in = open('parmed_in', "w")
1635: for group in range(1, len(groups.keys()) + 1):1373: for group in range(1, len(groups.keys()) + 1):
1636:     string = 'addExclusions '1374:     string = 'addExclusions '
1637:     string2 = '@'1375:     string2 = '@'
1638:     counter = 11376:     counter = 1
1639:     for res in groups[group]:1377:     for res in groups[group]:
1640:         for atom in res_dic[res]:1378:         for atom in res_dic[res]:


legend
Lines Added 
Lines changed
 Lines Removed

hdiff - version: 2.1.0