def resp_fitting(stpdbf, lgpdbf, stfpf, lgfpf, mklogf, ionids,\
ffchoice, mol2fs, metcenres2, chgmod, fixchg_resids, g0x, lgchg):
print("******************************************************************")
print("* *")
print("*======================RESP Charge fitting=======================*")
print("* *")
print("******************************************************************")
gene_resp_input_file(lgpdbf, ionids, stfpf, ffchoice, mol2fs, chgmod,
fixchg_resids, lgchg)
#-------------------------------------------------------------------------
####################RESP charge fitting###################################
#-------------------------------------------------------------------------
print('***Doing the RESP charge fiting...')
espf = mklogf.strip('.log') + '.esp'
if g0x in ['g03', 'g09']:
get_esp_from_gau(mklogf, espf)
elif g0x == 'gms':
get_esp_from_gms(mklogf, espf)
os.system("resp -O -i resp1.in -o resp1.out -p resp1.pch -t resp1.chg \
-e %s -s resp1_calc.esp" % espf)
os.system("resp -O -i resp2.in -o resp2.out -p resp2.pch -q resp1.chg \
-t resp2.chg -e %s -s resp2_calc.esp" % espf)
#-------------------------------------------------------------------------
####################Collecting the atom type and charge data##############
#-------------------------------------------------------------------------
#------------Atom type----------
sddict = {} #get the atom type information from standard model
r_stfpf = open(stfpf, 'r')
for line in r_stfpf:
if line[0:4] != "LINK":
line = line.strip('\n')
line = line.split(' ')
line = [i for i in line if i != '']
if len(line[-1]) == 1:
line[-1] = line[-1] + ' '
sddict[line[0]] = line[-1]
r_stfpf.close()
#------------Charge-------------
chgs = read_resp_file('resp2.chg')
metcenres1 = [] #original name of the metal center residue
stlist = [] #get the atom name list from the standard model
stf = open(stfpf, 'r')
for line in stf:
if line[0:4] != "LINK":
line = line.strip('\n')
line = line.split()
stlist.append(line[0])
line = line[0].split('-')
lresname = line[0] + '-' + line[1]
if lresname not in metcenres1:
metcenres1.append(lresname)
stf.close()
llist = [] #get the atom name list from the large model
lf = open(lgfpf, 'r')
for line in lf:
line = line.strip('\n')
llist.append(line)
lf.close()
ldict = {} #get charge of the large model, one-to-one relationship
for i in range(0, len(llist)):
ldict[llist[i]] = chgs[i]
stdict = {} #get the charge of the standard model
for i in list(ldict.keys()):
if i in stlist:
stdict[i] = ldict[i]
#-------------------------------------------------------------------------
####################Checking Models#########################
#-------------------------------------------------------------------------
print("=========================Checking models==========================")
print('***Check the large model...')
if len(chgs) != len(llist):
raise pymsmtError('Error: the charges and atom numbers are mismatch '
'for the large model!')
else:
print('Good. The charges and atom numbers are match for the ' + \
'large model.')
print('Good. There are ' + str(len(llist)) + ' atoms in the ' + \
'large model.')
print('***Check the standard model...')
if len(stlist) != len(stdict):
raise pymsmtError('Error: the charges and atom numbers are mismatch '
'for the standard model!')
else:
print('Good. The charges and atom numbers are match for the ' + \
'standard model.')
print('Good. There are ' + str(len(stlist)) + ' atoms in the ' + \
'standard model.')
print('***Check the residue names provided...')
if len(metcenres1) != len(metcenres2):
print('You gave the residue names: ', str(metcenres2))
print('Database had them: ', str(metcenres1))
raise pymsmtError('Error: The number of the residue names given is '
'mismatch the database!')
else:
print('Good. The number of the residue names given matches ' + \
'the database.')
#-------------------------------------------------------------------------
####################Building mol2 files for modeling######################
#-------------------------------------------------------------------------
#Load the force field
libdict, chargedict = get_lib_dict(ffchoice)
for mol2f in mol2fs:
libdict1, chargedict1 = get_lib_dict(mol2f)
libdict.update(libdict1)
chargedict.update(chargedict1)
##get the bondlist
mol, atids, resids = get_atominfo_fpdb(stpdbf) #from standard pdb
blist = get_mc_blist(mol, atids, ionids, stfpf)
blist2 = [(i[0], i[1]) for i in blist]
print("=======================Building mol2 files========================")
#for each residue, print out the mol2 file
for i in range(0, len(resids)):
resconter = mol.residues[resids[i]].resconter #atom ids in the residue
resname1 = mol.residues[resids[i]].resname #load residue name
resname2 = metcenres2[i] #new residue name
#Backbone atoms use AMBER backbone atom types
#if resname1 in resnamel:
# for bbatm in ['N', 'H', 'CA', 'HA','C', 'O']:
# key1 = str(resids[i]) + '-' + resname1 + '-' + bbatm
# key2 = resname1 + '-' + bbatm
# sddict[key1] = libdict[key2][0]
#New id dict
iddict1 = {}
for j in range(0, len(resconter)):
iddict1[resconter[j]] = j + 1
#Bond list for each residue with new atom ids
blist_each = []
for k in blist2:
if set(resconter) & set(k) == set(k):
blist_each.append((iddict1[k[0]], iddict1[k[1]]))
print_mol2f(resids[i], resname1, resname2, resconter, mol, iddict1, \
sddict, stdict, blist_each)
def gene_pre_frcmod_file(ionids, naamol2f, stpdbf, stfpf, smresf, prefcdf,
ffchoice, gaff, frcmodfs, watermodel):
print("******************************************************************")
print("* *")
print("*===================Generate the Initial frcmod file=============*")
print("* *")
print("******************************************************************")
libdict = {}
chargedict = {}
for mol2f in naamol2f:
libdict1, chargedict1 = get_lib_dict(mol2f)
libdict.update(libdict1)
chargedict.update(chargedict1)
#get the parameter dicts
Params = get_parm_dict(ffchoice, gaff, frcmodfs)
massparms = Params.mass
bondparms = Params.bond
angparms = Params.ang
dihparms = Params.dih
impparms = Params.imp
nbparms = Params.nb
#--------------------------------------------------------------------------
#############Get the metal center information####################
#--------------------------------------------------------------------------
mol, atids, resids = get_atominfo_fpdb(stpdbf)
#get the blist
blist = get_mc_blist(mol, atids, ionids, stfpf)
#get_all_the_lists from standard model
all_list = get_all_list(mol, blist, atids, 10.0)
#atom type dictionary, key is the atom id, value is atom type
attypdict = {}
#atom ids which has been transfered to another atom type
atidtrans = []
#get the information for the three from finger print
fp = open(stfpf, 'r')
for line in fp:
if line[0:4] != "LINK":
atinfo, atid, attyp1st, symbol, attyp2nd = line.split()
atid = int(atid)
attyp1st = addspace(attyp1st)
attyp2nd = addspace(attyp2nd)
attypdict[atid] = (attyp1st, attyp2nd)
if attyp1st != attyp2nd:
atidtrans.append(atid)
fp.close()
print("Atoms which has changed the atom types:", atidtrans)
for atid in atidtrans:
resid = mol.atoms[atid].resid
resname = mol.residues[resid].resname
attyp1 = attypdict[atid][0]
attyp2 = attypdict[atid][1]
print(str(resid) + '-' + resname + '@' + str(atid) + '-' + \
mol.atoms[atid].atname + ' : ' + attyp1, '-->', attyp2)
#-------------------------------------------------------------------------
########Print the pre-generated frcmod files##############
#-------------------------------------------------------------------------
fmf = open(prefcdf, 'w')
#for atoms which changed atom types
print('REMARK GOES HERE, THIS FILE IS GENERATED BY MCPB.PY', file=fmf)
print('MASS', file=fmf)
#for metal ions
for i in ionids:
attyp = attypdict[i][1]
atname = mol.atoms[i].atname
if len(atname) > 1:
atname = atname[0] + atname[1:].lower()
massi = Mass[atname]
print('YES', attyp + ' ' + str(round(massi, 2)) + \
' ' + atname + ' ion', file=fmf)
#for ligating atoms
for atid in atidtrans:
if atid not in ionids: #not include metal ion
atyp1 = attypdict[atid][0]
atyp2 = attypdict[atid][1]
print('YES', atyp2 + massparms[atyp1], file=fmf)
#--------------------------------------------------------------------------
bondparamsdict1 = {} #For metal ions
bondparamsdict2 = {} #For the others
print(' ', file=fmf)
print('BOND', file=fmf)
#for bond
for bonds in all_list.bondlist:
i = bonds[0]
j = bonds[1]
if list(set(ionids) & set([i, j])) != []:
#The bonds which related to the ions
bondtyp2 = (attypdict[i][1], attypdict[j][1])
if (bondtyp2 not in list(bondparamsdict1.keys())) and (bondtyp2[::-1] \
not in list(bondparamsdict1.keys())):
bondparamsdict1[bondtyp2] = ' '
elif list(set(atidtrans) & set([i, j])) != []:
#The bonds related to the atoms which changed their atom types
bondtyp1 = (attypdict[i][0], attypdict[j][0])
bondtyp2 = (attypdict[i][1], attypdict[j][1])
if (bondtyp2 not in list(bondparamsdict2.keys())) and (bondtyp2[::-1] \
not in list(bondparamsdict2.keys())):
if bondtyp1 in list(bondparms.keys()):
bondparamsdict2[bondtyp2] = bondparms[bondtyp1]
elif bondtyp1[::-1] in list(bondparms.keys()):
bondparamsdict2[bondtyp2] = bondparms[bondtyp1[::-1]]
for i in sorted(list(bondparamsdict1.keys())):
print('NON', i[0] + '-' + i[1] + bondparamsdict1[i], file=fmf)
for i in sorted(list(bondparamsdict2.keys())):
print('YES', i[0] + '-' + i[1] + bondparamsdict2[i], file=fmf)
#--------------------------------------------------------------------------
coparas = []
r_smresf = open(smresf, 'r')
for line in r_smresf:
line = line.strip('\n')
line = line.split('-')
resid = int(line[1])
if ('GLY' in line) or ('KCO' in line) or ('ACE' in line):
if resid+1 not in resids:
coparas.append(resid)
r_smresf.close()
angparamsdict1 = {} #For metal ions
angparamsdict2 = {} #For the others
print(' ', file=fmf)
print('ANGL', file=fmf)
#for angle
for angs in all_list.anglist:
i = angs[0]
j = angs[1]
k = angs[2]
if list(set(ionids) & set(angs)) != []:
#The angles which related to the ions
angtyp2 = (attypdict[i][1], attypdict[j][1], attypdict[k][1])
if (angtyp2 not in list(angparamsdict1.keys())) and (angtyp2[::-1] \
not in list(angparamsdict1.keys())):
angparamsdict1[angtyp2] = ' '
#print >> fmf, 'NON', attypdict[i][1] + '-' + attypdict[j][1] + \
#'-' + attypdict[k][1]
elif list(set(atidtrans) & set(angs)) != []:
#The angles related to the atoms
#which changed their atom types
angtyp1 = (attypdict[i][0], attypdict[j][0], attypdict[k][0])
angtyp2 = (attypdict[i][1], attypdict[j][1], attypdict[k][1])
if (angtyp2 not in list(angparamsdict2.keys())) and (angtyp2[::-1] \
not in list(angparamsdict2.keys())):
if angtyp1 in list(angparms.keys()):
angparamsdict2[angtyp2] = angparms[angtyp1]
elif angtyp1[::-1] in list(angparms.keys()):
angparamsdict2[angtyp2] = angparms[angtyp1[::-1]]
#Add for a specific situation
for i in coparas:
for atid in atidtrans:
if mol.atoms[atid].atname == 'O' and mol.atoms[atid].resid == i:
angtyp1 = (attypdict[atid][0], 'C ', 'N ')
angtyp2 = (attypdict[atid][1], 'C ', 'N ')
if (angtyp2 not in list(angparamsdict2.keys())) and (angtyp2[::-1] \
not in list(angparamsdict2.keys())):
if angtyp1 in list(angparms.keys()):
angparamsdict2[angtyp2] = angparms[angtyp1]
elif angtyp1[::-1] in list(angparms.keys()):
angparamsdict2[angtyp2] = angparms[angtyp1[::-1]]
for i in sorted(list(angparamsdict1.keys())):
print('NON', i[0] + '-' + i[1] + '-' + i[2] + angparamsdict1[i], file=fmf)
for i in sorted(list(angparamsdict2.keys())):
print('YES', i[0] + '-' + i[1] + '-' + i[2] + angparamsdict2[i], file=fmf)
#--------------------------------------------------------------------------
dihparamsdict = {}
#for dihedral
for dihs in all_list.dihlist:
i = dihs[0]
j = dihs[1]
k = dihs[2]
l = dihs[3]
if list(set(ionids) & set(dihs)) != []:
#The dihedral related to the metal ions
dihtyp1 = (attypdict[i][0], attypdict[j][0], attypdict[k][0], \
attypdict[l][0])
dihtyp1n = (attypdict[i][1], attypdict[j][1], attypdict[k][1], \
attypdict[l][1])
if (dihtyp1 not in list(dihparamsdict.keys())) and (dihtyp1[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = [' 3 0.00 0.0 ', \
' 3. ', ' ']
elif list(set(atidtrans) & set(dihs)) != []:
if list(set(atidtrans) & set(dihs[0::3])) == []:
#Neither the 1st and 4th atom change atom types
#There is 2nd or 3rd or both changed atom type(s)
dihtyp1 = (attypdict[i][0], attypdict[j][0], attypdict[k][0], \
attypdict[l][0])
dihtyp1n = (attypdict[i][1], attypdict[j][1], attypdict[k][1], \
attypdict[l][1])
dihtyp2 = ('X ', attypdict[j][0], attypdict[k][0], 'X ')
dihtyp2n = ('X ', attypdict[j][1], attypdict[k][1], 'X ')
if dihtyp1 in list(dihparms.keys()):
if (dihtyp1n not in list(dihparamsdict.keys())) and (dihtyp1n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = dihparms[dihtyp1]
elif dihtyp1[::-1] in list(dihparms.keys()):
if (dihtyp1n not in list(dihparamsdict.keys())) and (dihtyp1n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = dihparms[dihtyp1[::-1]]
elif dihtyp2 in list(dihparms.keys()):
if (dihtyp2n not in list(dihparamsdict.keys())) and (dihtyp2n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp2n] = dihparms[dihtyp2]
elif dihtyp2[::-1] in list(dihparms.keys()):
if (dihtyp2n not in list(dihparamsdict.keys())) and (dihtyp2n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp2n] = dihparms[dihtyp2[::-1]]
else:
if (dihtyp1n not in list(dihparamsdict.keys())) and (dihtyp1n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = [' 3 0.00 0.0 ', \
' 3. ', ' ']
else:
#There is 1st or 4th atoms or both changed the atom type(s)
dihtyp1 = (attypdict[i][0], attypdict[j][0], attypdict[k][0], \
attypdict[l][0])
dihtyp1n = (attypdict[i][1], attypdict[j][1], attypdict[k][1], \
attypdict[l][1])
dihtyp2 = ('X ', attypdict[j][1], attypdict[k][1], 'X ')
if dihtyp1 in list(dihparms.keys()):
if (dihtyp1n not in list(dihparamsdict.keys())) and (dihtyp1n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = dihparms[dihtyp1]
elif dihtyp1[::-1] in list(dihparms.keys()):
if (dihtyp1n not in list(dihparamsdict.keys())) and (dihtyp1n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = dihparms[dihtyp1[::-1]]
else:
if (dihtyp2 in list(dihparms.keys())) or (dihtyp2[::-1] \
in list(dihparms.keys())):
continue
elif (dihtyp1n not in list(dihparamsdict.keys())) and (dihtyp1n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = [' 3 0.00 0.0 ', \
' 3. ', ' ']
#Add for a specfic situation
for i in coparas:
for atid in atidtrans:
if mol.atoms[atid].atname == 'O' and mol.atoms[atid].resid == i:
for ionid in ionids:
if ((atid, ionid, 1) in all_list.bondlist) or \
((ionid, atid, 1) in all_list.bondlist):
dihtyp1 = (attypdict[ionid][0], attypdict[atid][0], 'C ', 'N ')
dihtyp2 = (attypdict[ionid][1], attypdict[atid][1], 'C ', 'N ')
if (dihtyp2 not in dihparamsdict) and (dihtyp2[::-1] not in dihparamsdict):
if dihtyp1 in list(dihparms.keys()):
dihparamsdict[dihtyp2] = dihparms[dihtyp1]
elif dihtyp1[::-1] in list(dihparms.keys()):
dihparamsdict[dihtyp2] = dihparms[dihtyp1[::-1]]
else:
dihparamsdict[dihtyp2] = [' 3 0.00 0.0 ', \
' 3. ', ' ']
print(' ', file=fmf)
print('DIHE', file=fmf)
for keyv in sorted(list(dihparamsdict.keys())):
if 'X ' not in keyv: #For types don't contain X
valv = dihparamsdict[keyv]
keyv = keyv[0] + '-' + keyv[1] + '-' + keyv[2] + '-' + keyv[3]
terms = len(valv)//3
for i in range(0, terms):
temp = i * 3
print('YES', keyv, valv[temp] + valv[temp+1] + \
valv[temp+2], file=fmf)
for keyv in sorted(list(dihparamsdict.keys())):
if 'X ' in keyv: #For types contain X
valv = dihparamsdict[keyv]
keyv = keyv[0] + '-' + keyv[1] + '-' + keyv[2] + '-' + keyv[3]
terms = len(valv)//3
for i in range(0, terms):
temp = i * 3
print('YES', keyv, valv[temp] + valv[temp+1] + \
valv[temp+2], file=fmf)
#--------------------------------------------------------------------------
impparamsdict = {}
#For improper torsion
for imps in all_list.implist:
i = imps[0]
j = imps[1]
k = imps[2]
l = imps[3]
if list(set(ionids) & set(imps)) != []:
continue
elif list(set(atidtrans) & set(imps)) != []:
imptyps = {}
#1 situation
imptyp1 = (attypdict[i][0], attypdict[j][0], attypdict[k][0], \
attypdict[l][0])
imptyp1n = (attypdict[i][1], attypdict[j][1], attypdict[k][1], \
attypdict[l][1])
#3 situations
imptyp2 = ('X ', 'X ', attypdict[k][0], attypdict[i][0])
imptyp2n = ('X ', 'X ', attypdict[k][1], attypdict[i][1])
imptyp3 = ('X ', 'X ', attypdict[k][0], attypdict[j][0])
imptyp3n = ('X ', 'X ', attypdict[k][1], attypdict[j][1])
imptyp4 = ('X ', 'X ', attypdict[k][0], attypdict[l][0])
imptyp4n = ('X ', 'X ', attypdict[k][1], attypdict[l][1])
#6 situations
imptyp5 = ('X ', attypdict[i][0], attypdict[k][0], attypdict[j][0])
imptyp5n = ('X ', attypdict[i][1], attypdict[k][1], attypdict[j][1])
imptyp6 = ('X ', attypdict[j][0], attypdict[k][0], attypdict[i][0])
imptyp6n = ('X ', attypdict[j][1], attypdict[k][1], attypdict[i][1])
imptyp7 = ('X ', attypdict[i][0], attypdict[k][0], attypdict[l][0])
imptyp7n = ('X ', attypdict[i][0], attypdict[k][1], attypdict[l][1])
imptyp8 = ('X ', attypdict[l][0], attypdict[k][0], attypdict[i][0])
imptyp8n = ('X ', attypdict[l][1], attypdict[k][1], attypdict[i][1])
imptyp9 = ('X ', attypdict[j][0], attypdict[k][0], attypdict[l][0])
imptyp9n = ('X ', attypdict[j][1], attypdict[k][1], attypdict[l][1])
imptyp10 = ('X ', attypdict[l][0], attypdict[k][0], attypdict[j][0])
imptyp10n = ('X ', attypdict[l][1], attypdict[k][1], attypdict[j][1])
imptyps[imptyp1] = imptyp1n
imptyps[imptyp2] = imptyp2n
imptyps[imptyp3] = imptyp3n
imptyps[imptyp4] = imptyp4n
imptyps[imptyp5] = imptyp5n
imptyps[imptyp6] = imptyp6n
imptyps[imptyp7] = imptyp7n
imptyps[imptyp8] = imptyp8n
imptyps[imptyp9] = imptyp9n
imptyps[imptyp10] = imptyp10n
for imptypkey in list(imptyps.keys()):
if imptypkey in list(impparms.keys()):
impparamsdict[imptyps[imptypkey]] = impparms[imptypkey]
print(' ', file=fmf)
print('IMPR', file=fmf)
#for improper torsion
for i in sorted(list(impparamsdict.keys())):
if i not in list(impparms.keys()):
imptypkey = i[0] + '-' + i[1] + '-' + i[2] + '-' + i[3]
print('YES', imptypkey, impparamsdict[i], file=fmf)
#--------------------------------------------------------------------------
#for nb
print(' ', file=fmf)
print('NONB', file=fmf)
#For metal ions
IonLJParaDict = get_ionljparadict(watermodel)
for i in ionids:
element = mol.atoms[i].element
chg = int(round(chargedict[mol.atoms[i].resname], 0))
attyp2 = attypdict[i][1]
mnum = max([9-chg, chg])
for j in range(0, mnum):
fchg1 = chg - j
fchg2 = chg + j
if j == 0 and element+str(fchg1) in list(IonLJParaDict.keys()):
rmin = IonLJParaDict[element + str(fchg1)][0]
ep = IonLJParaDict[element + str(fchg1)][1]
annot = IonLJParaDict[element + str(fchg1)][2]
break
elif fchg1 > 0 and element+str(fchg1) in list(IonLJParaDict.keys()):
print("Could not find VDW radius for element %s with charge "
"+%d, use the one of charge +%d" %(element, chg, fchg1))
rmin = IonLJParaDict[element + str(fchg1)][0]
ep = IonLJParaDict[element + str(fchg1)][1]
annot = IonLJParaDict[element + str(fchg1)][2]
break
elif fchg2 <= 8 and element+str(fchg2) in list(IonLJParaDict.keys()):
print("Could not find VDW radius for element %s with charge "
"+%d, use the one of charge +%d" %(element, chg, fchg2))
rmin = IonLJParaDict[element + str(fchg2)][0]
ep = IonLJParaDict[element + str(fchg2)][1]
annot = IonLJParaDict[element + str(fchg2)][2]
break
if rmin is None:
raise pymsmtError("Could not find VDW parameters/radius for "
"element %s with charge +%d " %(element, chg))
print('YES %s %8.4f %13.10f %-s' %(attyp2, rmin, \
ep, annot), file=fmf)
#For the others
for atid in atidtrans:
if atid not in ionids:
attyp1 = attypdict[atid][0]
attyp2 = attypdict[atid][1]
print('YES ', attyp2 + nbparms[attyp1], file=fmf)
print(' ', file=fmf)
print(' ', file=fmf)
fmf.close()
#--------------------------------------------------------------------------
#Move the file, delete the repeat parts
os.system("mv %s temp" %prefcdf)
os.system("uniq temp > %s" %prefcdf)
os.system("rm temp")
def gene_resp_input_file(lgpdbf, ionids, stfpf, ffchoice, mol2fs, chgmod,
fixchg_resids, lgchg):
libdict, chargedict = get_lib_dict(ffchoice)
for mol2f in mol2fs:
libdict1, chargedict1 = get_lib_dict(mol2f)
libdict.update(libdict1)
chargedict.update(chargedict1)
mol, atids, resids = get_atominfo_fpdb(lgpdbf)
reslist = get_reslist(mol, resids)
blist = get_mc_blist(mol, atids, ionids, stfpf)
bnoatids = [] #Binding backbone N and C Atom IDs
mcresids = [] #Metal site residues
stfpff = open(stfpf, 'r')
for line in stfpff:
if line[0:4] != 'LINK':
line = line.split()
line = line[0].split('-')
mcresids.append(int(line[0]))
else:
line = line.strip('\n')
line = line.split()
if (line[-1][-1] in ['N3', 'N', 'O', 'OXT']):
atid, atom = line[-1].split('-')
bnoatids.append(int(atid))
stfpff.close()
bnoresids = [] #Binding Backbone N and C Residue IDs, which are not fitted
#with backbone restriction in the charge fitting
for i in bnoatids:
resid = mol.atoms[i].resid
if resid not in bnoresids:
bnoresids.append(resid)
angresids = [] #ACE, NME, GLY residues
for i in resids:
if i not in mcresids:
angresids.append(i)
#Get the total charge of the system-------------------------------------
totchg = 0.0
for i in resids:
resname = mol.residues[i].resname
if i in reslist.nterm:
reschg = chargedict['N' + resname]
elif i in reslist.cterm:
reschg = chargedict['C' + resname]
else:
reschg = chargedict[resname]
totchg = totchg + reschg
totchg = int(round(totchg, 0))
if lgchg == -99:
lgchg = totchg
#-------------------------------------------------------------------------
##############RESP1.IN file###############################################
#-------------------------------------------------------------------------
print("***Generating the 1st stage resp charge fitting input file...")
#print the 1st part, the title
fresp1 = open('resp1.in', 'w')
print("Resp charges for organic molecule", file=fresp1)
print(" ", file=fresp1)
print(" &cntrl", file=fresp1)
print(" ", file=fresp1)
print(" nmol = 1,", file=fresp1)
print(" ihfree = 1,", file=fresp1)
print(" ioutopt = 1,", file=fresp1)
print(" ", file=fresp1)
print(" &end", file=fresp1)
print(" 1.0", file=fresp1)
print("Resp charges for organic molecule", file=fresp1)
print("%5d" % lgchg, end=' ', file=fresp1)
print("%4d" % len(atids), file=fresp1)
#2. print the 2nd part, the free and fozen atoms---------------------------
natids = [i for i in range(1, len(atids) + 1)] #new atids
iddict = {
} #First number in iddict is new atom id, second is atomic number
for i in range(0, len(atids)):
iddict[atids[i]] = natids[i]
for i in atids:
element = mol.atoms[i].element
elenum = Atnum[element]
iddict[i] = (iddict[i], elenum)
for i in resids:
get_equal_atoms(mol, i, blist, iddict)
#other atoms (except the CH2 and CH3 groups) are frozen
for i in atids:
if (len(iddict[i]) == 2):
iddict[i] = (iddict[i][0], iddict[i][1], -99)
for i in atids:
#if iddict[i][2] == -99:
print("%5d" % iddict[i][1], end=' ', file=fresp1)
print("%4s" % '0', file=fresp1)
#else:
# print >> fresp1, "%5d" %iddict[i][1],
# print >> fresp1, "%4s" %iddict[i][2]
fresp1.close()
add_restriction('resp1.in', libdict, mol, resids, reslist, mcresids,
bnoresids, angresids, iddict, chgmod, fixchg_resids)
#-------------------------------------------------------------------------
####################RESP2.IN file#########################################
#-------------------------------------------------------------------------
print("***Generating the 2nd stage resp charge fitting input file...")
#1. print the 1st part, the title------------------------------------------
fresp2 = open('resp2.in', 'w')
print("Resp charges for organic molecule", file=fresp2)
print(" ", file=fresp2)
print(" &cntrl", file=fresp2)
print(" ", file=fresp2)
print(" nmol = 1,", file=fresp2)
print(" ihfree = 1,", file=fresp2)
print(" ioutopt = 1,", file=fresp2)
print(" iqopt = 2,", file=fresp2)
print(" qwt = 0.001,", file=fresp2)
print(" ", file=fresp2)
print(" &end", file=fresp2)
print(" 1.0", file=fresp2)
print("Resp charges for organic molecule", file=fresp2)
print("%5d" % lgchg, end=' ', file=fresp2)
print("%4d" % len(atids), file=fresp2)
#2. print the 2nd part, the free or frozen information---------------------
for i in atids:
print("%5d" % iddict[i][1], end=' ', file=fresp2)
print("%4s" % iddict[i][2], file=fresp2)
fresp2.close()
add_restriction('resp2.in', libdict, mol, resids, reslist, mcresids,
bnoresids, angresids, iddict, chgmod, fixchg_resids)
def resp_fitting(stpdbf, lgpdbf, stfpf, lgfpf, mklogf, ionids,\
ffchoice, mol2fs, metcenres2, chgmod, fixchg_resids, g0x, lgchg):
print("******************************************************************")
print("* *")
print("*======================RESP Charge fitting=======================*")
print("* *")
print("******************************************************************")
gene_resp_input_file(lgpdbf, ionids, stfpf, ffchoice, mol2fs,
chgmod, fixchg_resids, lgchg)
#-------------------------------------------------------------------------
####################RESP charge fitting###################################
#-------------------------------------------------------------------------
print('***Doing the RESP charge fiting...')
espf = mklogf.strip('.log') + '.esp'
if g0x in ['g03', 'g09']:
get_esp_from_gau(mklogf, espf)
elif g0x == 'gms':
get_esp_from_gms(mklogf, espf)
os.system("resp -O -i resp1.in -o resp1.out -p resp1.pch -t resp1.chg \
-e %s -s resp1_calc.esp" %espf)
os.system("resp -O -i resp2.in -o resp2.out -p resp2.pch -q resp1.chg \
-t resp2.chg -e %s -s resp2_calc.esp" %espf)
#-------------------------------------------------------------------------
####################Collecting the atom type and charge data##############
#-------------------------------------------------------------------------
#------------Atom type----------
sddict = {} #get the atom type information from standard model
r_stfpf = open(stfpf, 'r')
for line in r_stfpf:
if line[0:4] != "LINK":
line = line.strip('\n')
line = line.split(' ')
line = [i for i in line if i != '']
if len(line[-1]) == 1:
line[-1] = line[-1] + ' '
sddict[line[0]] = line[-1]
r_stfpf.close()
#------------Charge-------------
chgs = read_resp_file('resp2.chg')
metcenres1 = [] #original name of the metal center residue
stlist = [] #get the atom name list from the standard model
stf = open(stfpf, 'r')
for line in stf:
if line[0:4] != "LINK":
line = line.strip('\n')
line = line.split()
stlist.append(line[0])
line = line[0].split('-')
lresname = line[0] + '-' + line[1]
if lresname not in metcenres1:
metcenres1.append(lresname)
stf.close()
llist = [] #get the atom name list from the large model
lf = open(lgfpf, 'r')
for line in lf:
line = line.strip('\n')
llist.append(line)
lf.close()
ldict = {} #get charge of the large model, one-to-one relationship
for i in range(0, len(llist)):
ldict[llist[i]] = chgs[i]
stdict = {} #get the charge of the standard model
for i in list(ldict.keys()):
if i in stlist:
stdict[i] = ldict[i]
#-------------------------------------------------------------------------
####################Checking Models#########################
#-------------------------------------------------------------------------
print("=========================Checking models==========================")
print('***Check the large model...')
if len(chgs) != len(llist):
raise pymsmtError('Error: the charges and atom numbers are mismatch '
'for the large model!')
else:
print('Good. The charges and atom numbers are match for the ' + \
'large model.')
print('Good. There are ' + str(len(llist)) + ' atoms in the ' + \
'large model.')
print('***Check the standard model...')
if len(stlist) != len(stdict):
raise pymsmtError('Error: the charges and atom numbers are mismatch '
'for the standard model!')
else:
print('Good. The charges and atom numbers are match for the ' + \
'standard model.')
print('Good. There are ' + str(len(stlist)) + ' atoms in the ' + \
'standard model.')
print('***Check the residue names provided...')
if len(metcenres1) != len(metcenres2):
print('You gave the residue names: ', str(metcenres2))
print('Database had them: ', str(metcenres1))
raise pymsmtError('Error: The number of the residue names given is '
'mismatch the database!')
else:
print('Good. The number of the residue names given matches ' + \
'the database.')
#-------------------------------------------------------------------------
####################Building mol2 files for modeling######################
#-------------------------------------------------------------------------
#Load the force field
libdict, chargedict = get_lib_dict(ffchoice)
for mol2f in mol2fs:
libdict1, chargedict1 = get_lib_dict(mol2f)
libdict.update(libdict1)
chargedict.update(chargedict1)
##get the bondlist
mol, atids, resids = get_atominfo_fpdb(stpdbf) #from standard pdb
blist = get_mc_blist(mol, atids, ionids, stfpf)
blist2 = [(i[0], i[1]) for i in blist]
print("=======================Building mol2 files========================")
#for each residue, print out the mol2 file
for i in range(0, len(resids)):
resconter = mol.residues[resids[i]].resconter #atom ids in the residue
resname1 = mol.residues[resids[i]].resname #load residue name
resname2 = metcenres2[i] #new residue name
#Backbone atoms use AMBER backbone atom types
#if resname1 in resnamel:
# for bbatm in ['N', 'H', 'CA', 'HA','C', 'O']:
# key1 = str(resids[i]) + '-' + resname1 + '-' + bbatm
# key2 = resname1 + '-' + bbatm
# sddict[key1] = libdict[key2][0]
#New id dict
iddict1 = {}
for j in range(0, len(resconter)):
iddict1[resconter[j]] = j + 1
#Bond list for each residue with new atom ids
blist_each = []
for k in blist2:
if set(resconter) & set(k) == set(k):
blist_each.append((iddict1[k[0]], iddict1[k[1]]))
print_mol2f(resids[i], resname1, resname2, resconter, mol, iddict1, \
sddict, stdict, blist_each)
def gene_resp_input_file(lgpdbf, ionids, stfpf, ffchoice, mol2fs,
chgmod, fixchg_resids, lgchg):
libdict, chargedict = get_lib_dict(ffchoice)
for mol2f in mol2fs:
libdict1, chargedict1 = get_lib_dict(mol2f)
libdict.update(libdict1)
chargedict.update(chargedict1)
mol, atids, resids = get_atominfo_fpdb(lgpdbf)
reslist = get_reslist(mol, resids)
blist = get_mc_blist(mol, atids, ionids, stfpf)
bnoatids = [] #Binding backbone N and C Atom IDs
mcresids = [] #Metal site residues
stfpff = open(stfpf, 'r')
for line in stfpff:
if line[0:4] != 'LINK':
line = line.split()
line = line[0].split('-')
mcresids.append(int(line[0]))
else:
line = line.strip('\n')
line = line.split()
if (line[-1][-1] in ['N3', 'N', 'O', 'OXT']):
atid, atom = line[-1].split('-')
bnoatids.append(int(atid))
stfpff.close()
bnoresids = [] #Binding Backbone N and C Residue IDs, which are not fitted
#with backbone restriction in the charge fitting
for i in bnoatids:
resid = mol.atoms[i].resid
if resid not in bnoresids:
bnoresids.append(resid)
angresids = [] #ACE, NME, GLY residues
for i in resids:
if i not in mcresids:
angresids.append(i)
#Get the total charge of the system-------------------------------------
totchg = 0.0
for i in resids:
resname = mol.residues[i].resname
if i in reslist.nterm:
reschg = chargedict['N' + resname]
elif i in reslist.cterm:
reschg = chargedict['C' + resname]
else:
reschg = chargedict[resname]
totchg = totchg + reschg
totchg = int(round(totchg, 0))
if lgchg == -99:
lgchg = totchg
#-------------------------------------------------------------------------
##############RESP1.IN file###############################################
#-------------------------------------------------------------------------
print("***Generating the 1st stage resp charge fitting input file...")
#print the 1st part, the title
fresp1 = open('resp1.in', 'w')
print("Resp charges for organic molecule", file=fresp1)
print(" ", file=fresp1)
print(" &cntrl", file=fresp1)
print(" ", file=fresp1)
print(" nmol = 1,", file=fresp1)
print(" ihfree = 1,", file=fresp1)
print(" ioutopt = 1,", file=fresp1)
print(" ", file=fresp1)
print(" &end", file=fresp1)
print(" 1.0", file=fresp1)
print("Resp charges for organic molecule", file=fresp1)
print("%5d" %lgchg, end=' ', file=fresp1)
print("%4d" %len(atids), file=fresp1)
#2. print the 2nd part, the free and fozen atoms---------------------------
natids = [i for i in range(1, len(atids)+1)] #new atids
iddict = {} #First number in iddict is new atom id, second is atomic number
for i in range(0, len(atids)):
iddict[atids[i]] = natids[i]
for i in atids:
element = mol.atoms[i].element
elenum = Atnum[element]
iddict[i] = (iddict[i], elenum)
for i in resids:
get_equal_atoms(mol, i, blist, iddict)
#other atoms (except the CH2 and CH3 groups) are frozen
for i in atids:
if (len(iddict[i]) == 2):
iddict[i] = (iddict[i][0], iddict[i][1], -99)
for i in atids:
#if iddict[i][2] == -99:
print("%5d" %iddict[i][1], end=' ', file=fresp1)
print("%4s" %'0', file=fresp1)
#else:
# print >> fresp1, "%5d" %iddict[i][1],
# print >> fresp1, "%4s" %iddict[i][2]
fresp1.close()
add_restriction('resp1.in', libdict, mol, resids, reslist, mcresids,
bnoresids, angresids, iddict, chgmod, fixchg_resids)
#-------------------------------------------------------------------------
####################RESP2.IN file#########################################
#-------------------------------------------------------------------------
print("***Generating the 2nd stage resp charge fitting input file...")
#1. print the 1st part, the title------------------------------------------
fresp2 = open('resp2.in', 'w')
print("Resp charges for organic molecule", file=fresp2)
print(" ", file=fresp2)
print(" &cntrl", file=fresp2)
print(" ", file=fresp2)
print(" nmol = 1,", file=fresp2)
print(" ihfree = 1,", file=fresp2)
print(" ioutopt = 1,", file=fresp2)
print(" iqopt = 2,", file=fresp2)
print(" qwt = 0.001,", file=fresp2)
print(" ", file=fresp2)
print(" &end", file=fresp2)
print(" 1.0", file=fresp2)
print("Resp charges for organic molecule", file=fresp2)
print("%5d" %lgchg, end=' ', file=fresp2)
print("%4d" %len(atids), file=fresp2)
#2. print the 2nd part, the free or frozen information---------------------
for i in atids:
print("%5d" %iddict[i][1], end=' ', file=fresp2)
print("%4s" %iddict[i][2], file=fresp2)
fresp2.close()
add_restriction('resp2.in', libdict, mol, resids, reslist, mcresids,
bnoresids, angresids, iddict, chgmod, fixchg_resids)
def gene_pre_frcmod_file(ionids, naamol2f, stpdbf, stfpf, smresf, prefcdf,
ffchoice, gaff, frcmodfs, watermodel):
print("******************************************************************")
print("* *")
print("*===================Generate the Initial frcmod file=============*")
print("* *")
print("******************************************************************")
libdict = {}
chargedict = {}
for mol2f in naamol2f:
libdict1, chargedict1 = get_lib_dict(mol2f)
libdict.update(libdict1)
chargedict.update(chargedict1)
#get the parameter dicts
Params = get_parm_dict(ffchoice, gaff, frcmodfs)
massparms = Params.mass
bondparms = Params.bond
angparms = Params.ang
dihparms = Params.dih
impparms = Params.imp
nbparms = Params.nb
ljedparms = Params.ljed
#--------------------------------------------------------------------------
#############Get the metal center information####################
#--------------------------------------------------------------------------
mol, atids, resids = get_atominfo_fpdb(stpdbf)
#get the blist
blist = get_mc_blist(mol, atids, ionids, stfpf)
#get_all_the_lists from standard model
all_list = get_all_list(mol, blist, atids, 10.0)
#atom type dictionary, key is the atom id, value is atom type
attypdict = {}
#atom ids which has been transfered to another atom type
atidtrans = []
#get the information for the three from finger print
fp = open(stfpf, 'r')
for line in fp:
if line[0:4] != "LINK":
atinfo, atid, attyp1st, symbol, attyp2nd = line.split()
atid = int(atid)
attyp1st = addspace(attyp1st)
attyp2nd = addspace(attyp2nd)
attypdict[atid] = (attyp1st, attyp2nd)
if attyp1st != attyp2nd:
atidtrans.append(atid)
fp.close()
print("Atoms which has changed the atom types:", atidtrans)
for atid in atidtrans:
resid = mol.atoms[atid].resid
resname = mol.residues[resid].resname
attyp1 = attypdict[atid][0]
attyp2 = attypdict[atid][1]
print(str(resid) + '-' + resname + '@' + str(atid) + '-' + \
mol.atoms[atid].atname + ' : ' + attyp1, '-->', attyp2)
#-------------------------------------------------------------------------
########Print the pre-generated frcmod files##############
#-------------------------------------------------------------------------
fmf = open(prefcdf, 'w')
#for atoms which changed atom types
print('REMARK GOES HERE, THIS FILE IS GENERATED BY MCPB.PY', file=fmf)
print('MASS', file=fmf)
#for metal ions
for i in ionids:
attyp = attypdict[i][1]
element = mol.atoms[i].element
massi = Mass[element]
print('YES', attyp + ' ' + str(round(massi, 2)) + \
' ' + element + ' ion', file=fmf)
#for ligating atoms
for atid in atidtrans:
if atid not in ionids: #not include metal ion
atyp1 = attypdict[atid][0]
atyp2 = attypdict[atid][1]
print('YES', atyp2 + massparms[atyp1], file=fmf)
#--------------------------------------------------------------------------
bondparamsdict1 = {} #For metal ions
bondparamsdict2 = {} #For the others
print(' ', file=fmf)
print('BOND', file=fmf)
#for bond
for bonds in all_list.bondlist:
i = bonds[0]
j = bonds[1]
if list(set(ionids) & set([i, j])) != []:
#The bonds which related to the ions
bondtyp2 = (attypdict[i][1], attypdict[j][1])
if (bondtyp2 not in list(bondparamsdict1.keys())) and (bondtyp2[::-1] \
not in list(bondparamsdict1.keys())):
bondparamsdict1[bondtyp2] = ' '
elif list(set(atidtrans) & set([i, j])) != []:
#The bonds related to the atoms which changed their atom types
bondtyp1 = (attypdict[i][0], attypdict[j][0])
bondtyp2 = (attypdict[i][1], attypdict[j][1])
if (bondtyp2 not in list(bondparamsdict2.keys())) and (bondtyp2[::-1] \
not in list(bondparamsdict2.keys())):
if bondtyp1 in list(bondparms.keys()):
bondparamsdict2[bondtyp2] = bondparms[bondtyp1]
elif bondtyp1[::-1] in list(bondparms.keys()):
bondparamsdict2[bondtyp2] = bondparms[bondtyp1[::-1]]
for i in sorted(list(bondparamsdict1.keys())):
print('NON', i[0] + '-' + i[1] + bondparamsdict1[i], file=fmf)
for i in sorted(list(bondparamsdict2.keys())):
print('YES', i[0] + '-' + i[1] + bondparamsdict2[i], file=fmf)
#--------------------------------------------------------------------------
coparas = []
r_smresf = open(smresf, 'r')
for line in r_smresf:
line = line.strip('\n')
line = line.split('-')
resid = int(line[1])
if ('GLY' in line) or ('KCO' in line) or ('ACE' in line):
if resid+1 not in resids:
coparas.append(resid)
r_smresf.close()
angparamsdict1 = {} #For metal ions
angparamsdict2 = {} #For the others
print(' ', file=fmf)
print('ANGL', file=fmf)
#for angle
for angs in all_list.anglist:
i = angs[0]
j = angs[1]
k = angs[2]
if list(set(ionids) & set(angs)) != []:
#The angles which related to the ions
angtyp2 = (attypdict[i][1], attypdict[j][1], attypdict[k][1])
if (angtyp2 not in list(angparamsdict1.keys())) and (angtyp2[::-1] \
not in list(angparamsdict1.keys())):
angparamsdict1[angtyp2] = ' '
#print >> fmf, 'NON', attypdict[i][1] + '-' + attypdict[j][1] + \
#'-' + attypdict[k][1]
elif list(set(atidtrans) & set(angs)) != []:
#The angles related to the atoms
#which changed their atom types
angtyp1 = (attypdict[i][0], attypdict[j][0], attypdict[k][0])
angtyp2 = (attypdict[i][1], attypdict[j][1], attypdict[k][1])
if (angtyp2 not in list(angparamsdict2.keys())) and (angtyp2[::-1] \
not in list(angparamsdict2.keys())):
if angtyp1 in list(angparms.keys()):
angparamsdict2[angtyp2] = angparms[angtyp1]
elif angtyp1[::-1] in list(angparms.keys()):
angparamsdict2[angtyp2] = angparms[angtyp1[::-1]]
#Add for a specific situation
for i in coparas:
for atid in atidtrans:
if mol.atoms[atid].atname == 'O' and mol.atoms[atid].resid == i:
angtyp1 = (attypdict[atid][0], 'C ', 'N ')
angtyp2 = (attypdict[atid][1], 'C ', 'N ')
if (angtyp2 not in list(angparamsdict2.keys())) and (angtyp2[::-1] \
not in list(angparamsdict2.keys())):
if angtyp1 in list(angparms.keys()):
angparamsdict2[angtyp2] = angparms[angtyp1]
elif angtyp1[::-1] in list(angparms.keys()):
angparamsdict2[angtyp2] = angparms[angtyp1[::-1]]
for i in sorted(list(angparamsdict1.keys())):
print('NON', i[0] + '-' + i[1] + '-' + i[2] + angparamsdict1[i], file=fmf)
for i in sorted(list(angparamsdict2.keys())):
print('YES', i[0] + '-' + i[1] + '-' + i[2] + angparamsdict2[i], file=fmf)
#--------------------------------------------------------------------------
dihparamsdict = {}
#for dihedral
for dihs in all_list.dihlist:
i = dihs[0]
j = dihs[1]
k = dihs[2]
l = dihs[3]
if list(set(ionids) & set(dihs)) != []:
# Treat the dihedrals related to the metal ions as zero
dihtyp1 = (attypdict[i][0], attypdict[j][0], attypdict[k][0], \
attypdict[l][0])
dihtyp1n = (attypdict[i][1], attypdict[j][1], attypdict[k][1], \
attypdict[l][1])
if (dihtyp1 not in list(dihparamsdict.keys())) and (dihtyp1[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = [' 3 0.00 0.00 ', 3, ' Treat as zero by MCPB.py']
elif list(set(atidtrans) & set(dihs)) != []:
if list(set(atidtrans) & set(dihs[0::3])) == []:
#Neither the 1st and 4th atom change atom types
#There is 2nd or 3rd or both changed atom type(s)
dihtyp1 = (attypdict[i][0], attypdict[j][0], attypdict[k][0], \
attypdict[l][0])
dihtyp1n = (attypdict[i][1], attypdict[j][1], attypdict[k][1], \
attypdict[l][1])
dihtyp2 = ('X ', attypdict[j][0], attypdict[k][0], 'X ')
dihtyp2n = ('X ', attypdict[j][1], attypdict[k][1], 'X ')
if dihtyp1 in list(dihparms.keys()):
if (dihtyp1n not in list(dihparamsdict.keys())) and (dihtyp1n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = dihparms[dihtyp1]
elif dihtyp1[::-1] in list(dihparms.keys()):
if (dihtyp1n not in list(dihparamsdict.keys())) and (dihtyp1n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = dihparms[dihtyp1[::-1]]
elif dihtyp2 in list(dihparms.keys()):
if (dihtyp2n not in list(dihparamsdict.keys())) and (dihtyp2n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp2n] = dihparms[dihtyp2]
elif dihtyp2[::-1] in list(dihparms.keys()):
if (dihtyp2n not in list(dihparamsdict.keys())) and (dihtyp2n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp2n] = dihparms[dihtyp2[::-1]]
else:
if (dihtyp1n not in list(dihparamsdict.keys())) and (dihtyp1n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = [' 3 0.00 0.00 ', 3, ' Treat as zero by MCPB.py']
else:
#There is 1st or 4th atoms or both changed the atom type(s)
dihtyp1 = (attypdict[i][0], attypdict[j][0], attypdict[k][0], \
attypdict[l][0])
dihtyp1n = (attypdict[i][1], attypdict[j][1], attypdict[k][1], \
attypdict[l][1])
dihtyp2 = ('X ', attypdict[j][1], attypdict[k][1], 'X ')
if dihtyp1 in list(dihparms.keys()):
if (dihtyp1n not in list(dihparamsdict.keys())) and (dihtyp1n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = dihparms[dihtyp1]
elif dihtyp1[::-1] in list(dihparms.keys()):
if (dihtyp1n not in list(dihparamsdict.keys())) and (dihtyp1n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = dihparms[dihtyp1[::-1]]
else:
if (dihtyp2 in list(dihparms.keys())) or (dihtyp2[::-1] \
in list(dihparms.keys())):
continue
elif (dihtyp1n not in list(dihparamsdict.keys())) and (dihtyp1n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = [' 3 0.00 0.00 ', 3, ' Treat as zero by MCPB.py']
#Add for a specfic situation
for i in coparas:
for atid in atidtrans:
if mol.atoms[atid].atname == 'O' and mol.atoms[atid].resid == i:
for ionid in ionids:
if ((atid, ionid, 1) in all_list.bondlist) or \
((ionid, atid, 1) in all_list.bondlist):
dihtyp1 = (attypdict[ionid][0], attypdict[atid][0], 'C ', 'N ')
dihtyp2 = (attypdict[ionid][1], attypdict[atid][1], 'C ', 'N ')
if (dihtyp2 not in dihparamsdict) and (dihtyp2[::-1] not in dihparamsdict):
if dihtyp1 in list(dihparms.keys()):
dihparamsdict[dihtyp2] = dihparms[dihtyp1]
elif dihtyp1[::-1] in list(dihparms.keys()):
dihparamsdict[dihtyp2] = dihparms[dihtyp1[::-1]]
else:
dihparamsdict[dihtyp2] = [' 3 0.00 0.00 ', 3, ' Treat as zero by MCPB.py']
print(' ', file=fmf)
print('DIHE', file=fmf)
# First is the term contains X and then the others, consistent with Amber
# manual
for keyv in sorted(list(dihparamsdict.keys())):
if 'X ' in keyv: #For types contain X
valv = dihparamsdict[keyv]
keyv = keyv[0] + '-' + keyv[1] + '-' + keyv[2] + '-' + keyv[3]
terms = len(valv)//3
for i in range(0, terms):
temp = i * 3
print('YES', keyv + valv[temp] + str(valv[temp+1]).rjust(3) + \
'.0' + valv[temp+2], file=fmf)
for keyv in sorted(list(dihparamsdict.keys())):
if 'X ' not in keyv: #For types don't contain X
valv = dihparamsdict[keyv]
keyv = keyv[0] + '-' + keyv[1] + '-' + keyv[2] + '-' + keyv[3]
terms = len(valv)//3
for i in range(0, terms):
temp = i * 3
print('YES', keyv + valv[temp] + str(valv[temp+1]).rjust(3) + \
'.0' + valv[temp+2], file=fmf)
#--------------------------------------------------------------------------
impparamsdict = {} # Dict for the new improper parameters
# For improper torsion, which is only not necessary term in Amber force
# field here the code only duplicates the available improper parameters
# for changed atom types
for imps in all_list.implist:
i = imps[0]
j = imps[1]
k = imps[2]
l = imps[3]
# For improper torsions related to metal ions, doesn't consider them
if list(set(ionids) & set(imps)) != []:
continue
elif list(set(atidtrans) & set(imps)) != []:
# Find all possible improper torsions which are related to the atoms
# whose atom types were changed, and get them into a dict
imptyps = {}
#1 situation for all atom representation
imptyp1 = (attypdict[i][0], attypdict[j][0], attypdict[k][0], \
attypdict[l][0])
imptyp1n = (attypdict[i][1], attypdict[j][1], attypdict[k][1], \
attypdict[l][1])
imptyp1 = seq_imp(imptyp1)
imptyp1n = seq_imp(imptyp1n)
#3 situations for two X used in the representation, i, j, l
imptyp2 = ('X ', 'X ', attypdict[k][0], attypdict[i][0])
imptyp2n = ('X ', 'X ', attypdict[k][1], attypdict[i][1])
imptyp2 = seq_imp(imptyp2)
imptyp2n = seq_imp(imptyp2n)
imptyp3 = ('X ', 'X ', attypdict[k][0], attypdict[j][0])
imptyp3n = ('X ', 'X ', attypdict[k][1], attypdict[j][1])
imptyp3 = seq_imp(imptyp3)
imptyp3n = seq_imp(imptyp3n)
imptyp4 = ('X ', 'X ', attypdict[k][0], attypdict[l][0])
imptyp4n = ('X ', 'X ', attypdict[k][1], attypdict[l][1])
imptyp4 = seq_imp(imptyp4)
imptyp4n = seq_imp(imptyp4n)
#6 situations for one X used in the representation: ij, ji, il, li, jl, lj
imptyp5 = ('X ', attypdict[i][0], attypdict[k][0], attypdict[j][0])
imptyp5n = ('X ', attypdict[i][1], attypdict[k][1], attypdict[j][1])
imptyp5 = seq_imp(imptyp5)
imptyp5n = seq_imp(imptyp5n)
imptyp6 = ('X ', attypdict[j][0], attypdict[k][0], attypdict[i][0])
imptyp6n = ('X ', attypdict[j][1], attypdict[k][1], attypdict[i][1])
imptyp6 = seq_imp(imptyp6)
imptyp6n = seq_imp(imptyp6n)
imptyp7 = ('X ', attypdict[i][0], attypdict[k][0], attypdict[l][0])
imptyp7n = ('X ', attypdict[i][0], attypdict[k][1], attypdict[l][1])
imptyp7 = seq_imp(imptyp7)
imptyp7n = seq_imp(imptyp7n)
imptyp8 = ('X ', attypdict[l][0], attypdict[k][0], attypdict[i][0])
imptyp8n = ('X ', attypdict[l][1], attypdict[k][1], attypdict[i][1])
imptyp8 = seq_imp(imptyp8)
imptyp8n = seq_imp(imptyp8n)
imptyp9 = ('X ', attypdict[j][0], attypdict[k][0], attypdict[l][0])
imptyp9n = ('X ', attypdict[j][1], attypdict[k][1], attypdict[l][1])
imptyp9 = seq_imp(imptyp9)
imptyp9n = seq_imp(imptyp9n)
imptyp10 = ('X ', attypdict[l][0], attypdict[k][0], attypdict[j][0])
imptyp10n = ('X ', attypdict[l][1], attypdict[k][1], attypdict[j][1])
imptyp10 = seq_imp(imptyp10)
imptyp10n = seq_imp(imptyp10n)
# If the improper torsion don't change, don't consider them, this
# is due to the old force field lib would be enough to deal with
# these situations
if imptyp1n != imptyp1:
imptyps[imptyp1] = imptyp1n
if imptyp2n != imptyp2:
imptyps[imptyp2] = imptyp2n
if imptyp3n != imptyp3:
imptyps[imptyp3] = imptyp3n
if imptyp4n != imptyp4:
imptyps[imptyp4] = imptyp4n
if imptyp5n != imptyp5:
imptyps[imptyp5] = imptyp5n
if imptyp6n != imptyp6:
imptyps[imptyp6] = imptyp6n
if imptyp7n != imptyp7:
imptyps[imptyp7] = imptyp7n
if imptyp8n != imptyp8:
imptyps[imptyp8] = imptyp8n
if imptyp9n != imptyp9:
imptyps[imptyp9] = imptyp9n
if imptyp10n != imptyp10:
imptyps[imptyp10] = imptyp10n
# If the corresponding old improper types available in the lib, then
# add the parameters to the impparamsdict for new improper types
for imptypkey in list(imptyps.keys()):
if imptypkey in list(impparms.keys()):
impparamsdict[imptyps[imptypkey]] = impparms[imptypkey]
print(' ', file=fmf)
print('IMPR', file=fmf)
# Print improper torsion, first has two Xs, then one X, then the others
for i in list(impparamsdict.keys()):
if i[0] == 'X ' and i[1] == 'X ':
imptypkey = i[0] + '-' + i[1] + '-' + i[2] + '-' + i[3]
print('YES', imptypkey + impparamsdict[i], file=fmf)
for i in list(impparamsdict.keys()):
if i[0] == 'X ' and i[1] != 'X ':
imptypkey = i[0] + '-' + i[1] + '-' + i[2] + '-' + i[3]
print('YES', imptypkey + impparamsdict[i], file=fmf)
for i in list(impparamsdict.keys()):
if 'X ' not in i:
imptypkey = i[0] + '-' + i[1] + '-' + i[2] + '-' + i[3]
print('YES', imptypkey + impparamsdict[i], file=fmf)
#--------------------------------------------------------------------------
#for nb
print(' ', file=fmf)
print('NONB', file=fmf)
#For metal ions
IonLJParaDict = get_ionljparadict(watermodel)
for i in ionids:
element = mol.atoms[i].element
chg = int(round(chargedict[mol.atoms[i].resname], 0))
attyp2 = attypdict[i][1]
mnum = max([9-chg, chg])
for j in range(0, mnum):
fchg1 = chg - j
fchg2 = chg + j
if j == 0 and element+str(fchg1) in list(IonLJParaDict.keys()):
rmin = IonLJParaDict[element + str(fchg1)][0]
ep = IonLJParaDict[element + str(fchg1)][1]
annot = IonLJParaDict[element + str(fchg1)][2]
break
elif fchg1 > 0 and element+str(fchg1) in list(IonLJParaDict.keys()):
print("Could not find VDW radius for element %s with charge "
"+%d, use the one of charge +%d" %(element, chg, fchg1))
rmin = IonLJParaDict[element + str(fchg1)][0]
ep = IonLJParaDict[element + str(fchg1)][1]
annot = IonLJParaDict[element + str(fchg1)][2]
break
elif fchg2 <= 8 and element+str(fchg2) in list(IonLJParaDict.keys()):
print("Could not find VDW radius for element %s with charge "
"+%d, use the one of charge +%d" %(element, chg, fchg2))
rmin = IonLJParaDict[element + str(fchg2)][0]
ep = IonLJParaDict[element + str(fchg2)][1]
annot = IonLJParaDict[element + str(fchg2)][2]
break
if rmin is None:
raise pymsmtError("Could not find VDW parameters/radius for "
"element %s with charge +%d " %(element, chg))
print('YES %s %8.4f %13.10f %-s' %(attyp2, rmin, \
ep, annot), file=fmf)
#For the others
for atid in atidtrans:
if atid not in ionids:
attyp1 = attypdict[atid][0]
attyp2 = attypdict[atid][1]
print('YES ', attyp2 + nbparms[attyp1], file=fmf)
print(' ', file=fmf)
print(' ', file=fmf)
fmf.close()
#--------------------------------------------------------------------------
#Move the file, delete the repeat parts
os.system("mv %s temp" %prefcdf)
os.system("uniq temp > %s" %prefcdf)
os.system("rm temp")
def gene_pre_frcmod_file(ionids, naamol2f, stpdbf, stfpf, smresf, prefcdf,
ffchoice, gaff, frcmodfs, watermodel):
print("******************************************************************")
print("* *")
print("*===================Generate the Initial frcmod file=============*")
print("* *")
print("******************************************************************")
libdict = {}
chargedict = {}
for mol2f in naamol2f:
libdict1, chargedict1 = get_lib_dict(mol2f)
libdict.update(libdict1)
chargedict.update(chargedict1)
#get the parameter dicts
Params = get_parm_dict(ffchoice, gaff, frcmodfs)
massparms = Params.mass
bondparms = Params.bond
angparms = Params.ang
dihparms = Params.dih
impparms = Params.imp
nbparms = Params.nb
#--------------------------------------------------------------------------
#############Get the metal center information####################
#--------------------------------------------------------------------------
mol, atids, resids = get_atominfo_fpdb(stpdbf)
#get the blist
blist = get_mc_blist(mol, atids, ionids, stfpf)
#get_all_the_lists from standard model
all_list = get_all_list(mol, blist, atids, 10.0)
#atom type dictionary, key is the atom id, value is atom type
attypdict = {}
#atom ids which has been transfered to another atom type
atidtrans = []
#get the information for the three from finger print
fp = open(stfpf, 'r')
for line in fp:
if line[0:4] != "LINK":
atinfo, atid, attyp1st, symbol, attyp2nd = line.split()
atid = int(atid)
attyp1st = addspace(attyp1st)
attyp2nd = addspace(attyp2nd)
attypdict[atid] = (attyp1st, attyp2nd)
if attyp1st != attyp2nd:
atidtrans.append(atid)
fp.close()
print("Atoms which has changed the atom types:", atidtrans)
for atid in atidtrans:
resid = mol.atoms[atid].resid
resname = mol.residues[resid].resname
attyp1 = attypdict[atid][0]
attyp2 = attypdict[atid][1]
print(str(resid) + '-' + resname + '@' + str(atid) + '-' + \
mol.atoms[atid].atname + ' : ' + attyp1, '-->', attyp2)
#-------------------------------------------------------------------------
########Print the pre-generated frcmod files##############
#-------------------------------------------------------------------------
fmf = open(prefcdf, 'w')
#for atoms which changed atom types
print('REMARK GOES HERE, THIS FILE IS GENERATED BY MCPB.PY', file=fmf)
print('MASS', file=fmf)
#for metal ions
for i in ionids:
attyp = attypdict[i][1]
atname = mol.atoms[i].atname
if len(atname) > 1:
atname = atname[0] + atname[1:].lower()
massi = Mass[atname]
print('YES', attyp + ' ' + str(round(massi, 2)) + \
' ' + atname + ' ion', file=fmf)
#for ligating atoms
for atid in atidtrans:
if atid not in ionids: #not include metal ion
atyp1 = attypdict[atid][0]
atyp2 = attypdict[atid][1]
print('YES', atyp2 + massparms[atyp1], file=fmf)
#--------------------------------------------------------------------------
bondparamsdict1 = {} #For metal ions
bondparamsdict2 = {} #For the others
print(' ', file=fmf)
print('BOND', file=fmf)
#for bond
for bonds in all_list.bondlist:
i = bonds[0]
j = bonds[1]
if list(set(ionids) & set(bonds)) != []:
#The bonds which related to the ions
bondtyp2 = (attypdict[i][1], attypdict[j][1])
if (bondtyp2 not in list(bondparamsdict1.keys())) and (bondtyp2[::-1] \
not in list(bondparamsdict1.keys())):
bondparamsdict1[bondtyp2] = ' '
elif list(set(atidtrans) & set(bonds)) != []:
#The bonds related to the atoms which changed their atom types
bondtyp1 = (attypdict[i][0], attypdict[j][0])
bondtyp2 = (attypdict[i][1], attypdict[j][1])
if (bondtyp2 not in list(bondparamsdict2.keys())) and (bondtyp2[::-1] \
not in list(bondparamsdict2.keys())):
if bondtyp1 in list(bondparms.keys()):
bondparamsdict2[bondtyp2] = bondparms[bondtyp1]
elif bondtyp1[::-1] in list(bondparms.keys()):
bondparamsdict2[bondtyp2] = bondparms[bondtyp1[::-1]]
for i in sorted(list(bondparamsdict1.keys())):
print('NON', i[0] + '-' + i[1] + bondparamsdict1[i], file=fmf)
for i in sorted(list(bondparamsdict2.keys())):
print('YES', i[0] + '-' + i[1] + bondparamsdict2[i], file=fmf)
#--------------------------------------------------------------------------
coparas = []
r_smresf = open(smresf, 'r')
for line in r_smresf:
line = line.strip('\n')
line = line.split('-')
resid = int(line[1])
if ('GLY' in line) or ('KCO' in line) or ('ACE' in line):
if resid+1 not in resids:
coparas.append(resid)
r_smresf.close()
angparamsdict1 = {} #For metal ions
angparamsdict2 = {} #For the others
print(' ', file=fmf)
print('ANGL', file=fmf)
#for angle
for angs in all_list.anglist:
i = angs[0]
j = angs[1]
k = angs[2]
if list(set(ionids) & set(angs)) != []:
#The angles which related to the ions
angtyp2 = (attypdict[i][1], attypdict[j][1], attypdict[k][1])
if (angtyp2 not in list(angparamsdict1.keys())) and (angtyp2[::-1] \
not in list(angparamsdict1.keys())):
angparamsdict1[angtyp2] = ' '
#print >> fmf, 'NON', attypdict[i][1] + '-' + attypdict[j][1] + \
#'-' + attypdict[k][1]
elif list(set(atidtrans) & set(angs)) != []:
#The angles related to the atoms
#which changed their atom types
angtyp1 = (attypdict[i][0], attypdict[j][0], attypdict[k][0])
angtyp2 = (attypdict[i][1], attypdict[j][1], attypdict[k][1])
if (angtyp2 not in list(angparamsdict2.keys())) and (angtyp2[::-1] \
not in list(angparamsdict2.keys())):
if angtyp1 in list(angparms.keys()):
angparamsdict2[angtyp2] = angparms[angtyp1]
elif angtyp1[::-1] in list(angparms.keys()):
angparamsdict2[angtyp2] = angparms[angtyp1[::-1]]
#Add for a specific situation
for i in coparas:
for atid in atidtrans:
if mol.atoms[atid].atname == 'O' and mol.atoms[atid].resid == i:
angtyp1 = (attypdict[atid][0], 'C ', 'N ')
angtyp2 = (attypdict[atid][1], 'C ', 'N ')
if (angtyp2 not in list(angparamsdict2.keys())) and (angtyp2[::-1] \
not in list(angparamsdict2.keys())):
if angtyp1 in list(angparms.keys()):
angparamsdict2[angtyp2] = angparms[angtyp1]
elif angtyp1[::-1] in list(angparms.keys()):
angparamsdict2[angtyp2] = angparms[angtyp1[::-1]]
for i in sorted(list(angparamsdict1.keys())):
print('NON', i[0] + '-' + i[1] + '-' + i[2] + angparamsdict1[i], file=fmf)
for i in sorted(list(angparamsdict2.keys())):
print('YES', i[0] + '-' + i[1] + '-' + i[2] + angparamsdict2[i], file=fmf)
#--------------------------------------------------------------------------
dihparamsdict = {}
#for dihedral
for dihs in all_list.dihlist:
i = dihs[0]
j = dihs[1]
k = dihs[2]
l = dihs[3]
if list(set(ionids) & set(dihs)) != []:
#The dihedral related to the metal ions
dihtyp1 = (attypdict[i][0], attypdict[j][0], attypdict[k][0], \
attypdict[l][0])
dihtyp1n = (attypdict[i][1], attypdict[j][1], attypdict[k][1], \
attypdict[l][1])
if (dihtyp1 not in list(dihparamsdict.keys())) and (dihtyp1[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = [' 3 0.00 0.0 ', \
' 3. ', ' ']
elif list(set(atidtrans) & set(dihs)) != []:
if list(set(atidtrans) & set(dihs[0::3])) == []:
#Neither the 1st and 4th atom change atom types
#There is 2nd or 3rd or both changed atom type(s)
dihtyp1 = (attypdict[i][0], attypdict[j][0], attypdict[k][0], \
attypdict[l][0])
dihtyp1n = (attypdict[i][1], attypdict[j][1], attypdict[k][1], \
attypdict[l][1])
dihtyp2 = ('X ', attypdict[j][0], attypdict[k][0], 'X ')
dihtyp2n = ('X ', attypdict[j][1], attypdict[k][1], 'X ')
if dihtyp1 in list(dihparms.keys()):
if (dihtyp1n not in list(dihparamsdict.keys())) and (dihtyp1n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = dihparms[dihtyp1]
elif dihtyp1[::-1] in list(dihparms.keys()):
if (dihtyp1n not in list(dihparamsdict.keys())) and (dihtyp1n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = dihparms[dihtyp1[::-1]]
elif dihtyp2 in list(dihparms.keys()):
if (dihtyp2n not in list(dihparamsdict.keys())) and (dihtyp2n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp2n] = dihparms[dihtyp2]
elif dihtyp2[::-1] in list(dihparms.keys()):
if (dihtyp2n not in list(dihparamsdict.keys())) and (dihtyp2n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp2n] = dihparms[dihtyp2[::-1]]
else:
if (dihtyp1n not in list(dihparamsdict.keys())) and (dihtyp1n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = [' 3 0.00 0.0 ', \
' 3. ', ' ']
else:
#There is 1st or 4th atoms or both changed the atom type(s)
dihtyp1 = (attypdict[i][0], attypdict[j][0], attypdict[k][0], \
attypdict[l][0])
dihtyp1n = (attypdict[i][1], attypdict[j][1], attypdict[k][1], \
attypdict[l][1])
dihtyp2 = ('X ', attypdict[j][1], attypdict[k][1], 'X ')
if dihtyp1 in list(dihparms.keys()):
if (dihtyp1n not in list(dihparamsdict.keys())) and (dihtyp1n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = dihparms[dihtyp1]
elif dihtyp1[::-1] in list(dihparms.keys()):
if (dihtyp1n not in list(dihparamsdict.keys())) and (dihtyp1n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = dihparms[dihtyp1[::-1]]
else:
if (dihtyp2 in list(dihparms.keys())) or (dihtyp2[::-1] \
in list(dihparms.keys())):
continue
elif (dihtyp1n not in list(dihparamsdict.keys())) and (dihtyp1n[::-1] \
not in list(dihparamsdict.keys())):
dihparamsdict[dihtyp1n] = [' 3 0.00 0.0 ', \
' 3. ', ' ']
#Add for a specfic situation
for i in coparas:
for atid in atidtrans:
if mol.atoms[atid].atname == 'O' and mol.atoms[atid].resid == i:
for ionid in ionids:
if ((atid, ionid, 1) in all_list.bondlist) or \
((ionid, atid, 1) in all_list.bondlist):
dihtyp1 = (attypdict[ionid][0], attypdict[atid][0], 'C ', 'N ')
dihtyp2 = (attypdict[ionid][1], attypdict[atid][1], 'C ', 'N ')
if (dihtyp2 not in dihparamsdict) and (dihtyp2[::-1] not in dihparamsdict):
if dihtyp1 in list(dihparms.keys()):
dihparamsdict[dihtyp2] = dihparms[dihtyp1]
elif dihtyp1[::-1] in list(dihparms.keys()):
dihparamsdict[dihtyp2] = dihparms[dihtyp1[::-1]]
else:
dihparamsdict[dihtyp2] = [' 3 0.00 0.0 ', \
' 3. ', ' ']
print(' ', file=fmf)
print('DIHE', file=fmf)
for keyv in sorted(list(dihparamsdict.keys())):
if 'X ' not in keyv: #For types don't contain X
valv = dihparamsdict[keyv]
keyv = keyv[0] + '-' + keyv[1] + '-' + keyv[2] + '-' + keyv[3]
terms = len(valv)//3
for i in range(0, terms):
temp = i * 3
print('YES', keyv, valv[temp] + valv[temp+1] + \
valv[temp+2], file=fmf)
for keyv in sorted(list(dihparamsdict.keys())):
if 'X ' in keyv: #For types contain X
valv = dihparamsdict[keyv]
keyv = keyv[0] + '-' + keyv[1] + '-' + keyv[2] + '-' + keyv[3]
terms = len(valv)//3
for i in range(0, terms):
temp = i * 3
print('YES', keyv, valv[temp] + valv[temp+1] + \
valv[temp+2], file=fmf)
#--------------------------------------------------------------------------
impparamsdict = {}
#For improper torsion
for imps in all_list.implist:
i = imps[0]
j = imps[1]
k = imps[2]
l = imps[3]
if list(set(ionids) & set(imps)) != []:
continue
elif list(set(atidtrans) & set(imps)) != []:
imptyps = {}
#1 situation
imptyp1 = (attypdict[i][0], attypdict[j][0], attypdict[k][0], \
attypdict[l][0])
imptyp1n = (attypdict[i][1], attypdict[j][1], attypdict[k][1], \
attypdict[l][1])
#3 situations
imptyp2 = ('X ', 'X ', attypdict[k][0], attypdict[i][0])
imptyp2n = ('X ', 'X ', attypdict[k][1], attypdict[i][1])
imptyp3 = ('X ', 'X ', attypdict[k][0], attypdict[j][0])
imptyp3n = ('X ', 'X ', attypdict[k][1], attypdict[j][1])
imptyp4 = ('X ', 'X ', attypdict[k][0], attypdict[l][0])
imptyp4n = ('X ', 'X ', attypdict[k][1], attypdict[l][1])
#6 situations
imptyp5 = ('X ', attypdict[i][0], attypdict[k][0], attypdict[j][0])
imptyp5n = ('X ', attypdict[i][1], attypdict[k][1], attypdict[j][1])
imptyp6 = ('X ', attypdict[j][0], attypdict[k][0], attypdict[i][0])
imptyp6n = ('X ', attypdict[j][1], attypdict[k][1], attypdict[i][1])
imptyp7 = ('X ', attypdict[i][0], attypdict[k][0], attypdict[l][0])
imptyp7n = ('X ', attypdict[i][0], attypdict[k][1], attypdict[l][1])
imptyp8 = ('X ', attypdict[l][0], attypdict[k][0], attypdict[i][0])
imptyp8n = ('X ', attypdict[l][1], attypdict[k][1], attypdict[i][1])
imptyp9 = ('X ', attypdict[j][0], attypdict[k][0], attypdict[l][0])
imptyp9n = ('X ', attypdict[j][1], attypdict[k][1], attypdict[l][1])
imptyp10 = ('X ', attypdict[l][0], attypdict[k][0], attypdict[j][0])
imptyp10n = ('X ', attypdict[l][1], attypdict[k][1], attypdict[j][1])
imptyps[imptyp1] = imptyp1n
imptyps[imptyp2] = imptyp2n
imptyps[imptyp3] = imptyp3n
imptyps[imptyp4] = imptyp4n
imptyps[imptyp5] = imptyp5n
imptyps[imptyp6] = imptyp6n
imptyps[imptyp7] = imptyp7n
imptyps[imptyp8] = imptyp8n
imptyps[imptyp9] = imptyp9n
imptyps[imptyp10] = imptyp10n
for imptypkey in list(imptyps.keys()):
if imptypkey in list(impparms.keys()):
impparamsdict[imptyps[imptypkey]] = impparms[imptypkey]
print(' ', file=fmf)
print('IMPR', file=fmf)
#for improper torsion
for i in sorted(list(impparamsdict.keys())):
if i not in list(impparms.keys()):
imptypkey = i[0] + '-' + i[1] + '-' + i[2] + '-' + i[3]
print('YES', imptypkey, impparamsdict[i], file=fmf)
#--------------------------------------------------------------------------
#for nb
print(' ', file=fmf)
print('NONB', file=fmf)
#For metal ions
IonLJParaDict = get_ionljparadict(watermodel)
for i in ionids:
element = mol.atoms[i].element
chg = str(int(chargedict[mol.atoms[i].resname]))
attyp2 = attypdict[i][1]
rmin = IonLJParaDict[element + chg][0]
ep = IonLJParaDict[element + chg][1]
annot = IonLJParaDict[element + chg][2]
print('YES %s %11.3f %13.10f %-s' %(attyp2, rmin, \
ep, annot), file=fmf)
#For the others
for atid in atidtrans:
if atid not in ionids:
attyp1 = attypdict[atid][0]
attyp2 = attypdict[atid][1]
print('YES ', attyp2 + nbparms[attyp1], file=fmf)
print(' ', file=fmf)
print(' ', file=fmf)
fmf.close()
#--------------------------------------------------------------------------
#Move the file, delete the repeat parts
os.system("mv %s temp" %prefcdf)
os.system("uniq temp > %s" %prefcdf)
os.system("rm temp")
