Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

from tautomer import Tautomer 

import config 

from math import ceil 

 

class Titsite: 

"""Titrable Site with more than one Tautomer""" 

def __init__(self, res_number, molecule): 

""" 

Args:  

res_number (int): number of the site in the .pdb  

and .sites file 

molecule (TitratingMolecule): molecule to 

which the Site belongs 

 

# Site Details 

self._res_name (str): residue name 

self._type (str): site type ('c' or 'a') 

'c' if site is cationic 

'a' if site is anionic 

self._center (list) : Site focus center 

if dimension is 0, then center is defined in cent file 

elif dimension is 2, then center (z) is defined in cent file 

and center (x, y) are defined in boxsize variable 

self._center_original (list): Site geometric center on  

cent file when dimension is 2 

 

# Site Tautomers 

self._tautomers (dict): tautomers of Site (except reference tautomer) 

key is tautomer name 

value is tautomer instance 

self._ref_tautomer (Tautomer): reference tautomer instance 

 

# Site Atoms 

self._atoms (dict): existing atoms in site 

key is atom id name 

value is atom id number 

""" 

self._molecule = molecule 

self._res_number = res_number 

self._res_name = '' 

self._atoms = {} 

self._tautomers = {} 

self._ref_tautomer = '' 

self._center = [] 

self._type = '' 

 

# Set Methods 

def setTautomers_old(self, res_tauts): 

"""Adds Tautomers from res_tauts to self._tautomers 

 

Args: 

res_tauts (list): tautomers from sites file 

""" 

for tautomer in res_tauts: 

self._res_name = tautomer[:3] 

correct_number = str(int(tautomer[-1]) - 1) 

tautomer = tautomer[:2] + correct_number 

 

tID = Tautomer(tautomer, self, self._molecule) 

self._tautomers[tautomer] = tID 

 

def setTautomers(self, ntauts, resname): 

"""Adds Tautomers from res_tauts to self._tautomers 

 

Args: 

res_tauts (list): tautomers from sites file 

""" 

for i in range(ntauts): 

self._res_name = resname 

correct_number = str(i) 

tautomer = resname[:2] + correct_number 

 

tID = Tautomer(tautomer, self, self._molecule) 

self._tautomers[tautomer] = tID 

 

def addReferenceTautomer(self): 

"""Gets last tautomer from .sites file adds one and saves it as the 

reference tautomer""" 

last_tautomer = max(sorted(self._tautomers.keys())) 

correct_number = str(int(last_tautomer[-1]) + 1) 

ref_tautomer = last_tautomer[:2] + correct_number 

tID = Tautomer(ref_tautomer, self, self._molecule) 

self._ref_tautomer = tID 

 

 

def addChargeSets(self): 

"""Stores the charge set of each existing tautomer  

for the present Site""" 

for tautomer in self._tautomers.values(): 

tautomer.loadChargeSet(self._res_name, 

self._ref_tautomer) 

 

def addAtom(self, aname, anumb): 

""" 

Args: 

aname (str): atom name 

anumb (int): atom id number 

""" 

self._atoms[aname] = anumb 

 

def addCenter(self, center, boxsize=False, box_z=False): 

x = center[0] 

y = center[1] 

z = center[2] 

if boxsize: 

if config.params['pbc_dim'] != 2: 

raise Exception('ERROR: The original center is only ' 

'needed for 2-dimensional calculation') 

self._center_original = [x, y, z] 

x = boxsize * 10 / 2 

y = boxsize * 10 / 2 

z += box_z * 10 

self._center = [x, y, z] 

 

def addCenterH(self, center): 

self._centerH = center 

 

def setType(self, stype): 

self._type = stype 

 

# Get Methods 

def getName(self): 

return self._res_name 

 

def getTautomers(self): 

"""Returns list of all tautomers instances  

except the tautomers of reference""" 

return self._tautomers.values() 

 

def getAtomNumbersList(self): 

return self._atoms.values() 

 

def getAtomNamesList(self): 

return self._atoms.keys() 

 

def getRefTautomerName(self): 

return self._ref_tautomer.getName() 

 

def getRefTautomer(self): 

return self._ref_tautomer 

 

def getMolecule(self): 

return self._molecule 

 

def getType(self): 

return self._type 

 

def getRefProtState(self): 

if self._type == 'c': 

reftau_prot_state = 1 

elif self._type == 'a': 

reftau_prot_state = -1 

return reftau_prot_state 

 

def getCenterOriginal(self): 

if config.params['pbc_dim'] != 2: 

raise Exception('ERROR: The original center is only ' 

'needed for 2-dimensional calculation') 

return self._center_original 

 

def getCenterH(self): 

return self._centerH 

 

def getCenter(self): 

return self._center 

 

def getResNumber(self): 

return self._res_number 

 

# Iter Methods 

def iterTautomers(self): 

for i in self._tautomers.values(): 

yield i 

 

def iterOrderedTautomersWithoutRef(self): 

for i in sorted(self._tautomers.keys()): 

yield self._tautomers[i] 

 

def getOrderedTautomersList(self): 

tmp = [] 

for i in sorted(self._tautomers.keys()): 

tmp.append(self._tautomers[i]) 

tmp.append(self._ref_tautomer) 

return tmp 

 

# Print Methods 

def __str__(self): 

tautomers = ' '.join(sorted(self._tautomers.keys())) 

natoms = len(self._atoms) 

center = [ round(i, 2) for i in self._center ] 

out = 'Site Number -> {0:5} '\ 

'Tautomers -> {1:30} '\ 

'Reference -> {2:5} '\ 

'NAtoms -> {3:6} '\ 

'Center -> {4}'.format(self._res_number,tautomers, 

self._ref_tautomer.getName(), 

natoms, center) 

return out