def DelPhiLaunch(self):
Config.loadParams(self.__parameters)
if self.get_total_sites() < 1:
raise Exception("At least one site has to be correctly defined.")
all_tautomers = list(self.iterAllSitesTautomers())
Config.parallel_params.all_tautomers_order = all_tautomers
# Runs DelPhi simulations for all tautomers
results = startPoolProcesses(runDelPhiSims, all_tautomers,
Config.pypka_params["ncpus"])
print("\rPB Runs Ended{:>80}".format(""))
# Calculates the pKint of all tautomers
self.calcpKint(results)
def run_mc(self):
def resize_list_of_lists(listn, maxsize, filler=None):
for i in listn:
diff = maxsize - len(i)
for ii in range(diff):
i.append(filler)
def calcpKhalfs(pH, nsites, avgs, pmean, pKs, mcsteps, dpH):
totalP = 0.0
means = []
for site in range(nsites):
mean = avgs[site] / float(mcsteps)
means.append(mean)
totalP += mean
p = pmean[site]
if p > 0.5 and mean <= 0.5 or p < 0.5 and mean >= 0.5:
pKhalf = pH - dpH * (mean - 0.5) / (mean - p)
for i in range(MAXNPKHALFS):
if pKs[site][i] == PKAPLACEHOLDER:
pKs[site][i] = pKhalf
break
elif p > 1.5 and mean <= 1.5 or p < 1.5 and mean >= 1.5:
pKhalf = pH - dpH * (mean - 1.5) / (mean - p)
for i in range(MAXNPKHALFS):
if pKs[site][i] == PKAPLACEHOLDER:
pKs[site][i] = pKhalf
break
pmean[site] = mean
totalP /= nsites
return totalP, pKs, pmean, means
Config.loadParams(self.__parameters)
print("\nStart MC", end="\r")
sites = self.get_all_sites(get_list=True)
nsites = len(sites)
# possible_states = [[] for _ in sites]
possible_states_g = [[] for _ in sites]
possible_states_occ = [[] for _ in sites]
temperature = float(Config.pypka_params["temp"])
isite = -1
for site in sites:
isite += 1
itaut = 0
for tautomer in site.iterOrderedTautomersWithoutRef():
dg = tautomer.dg / (KBOLTZ * temperature)
possible_states_g[isite].append(dg)
# possible_states[isite].append(itaut)
if site.type == "c":
prot_state = 0
elif site.type == "a":
prot_state = 1
possible_states_occ[isite].append(prot_state)
itaut += 1
if site.type == "c":
prot_state = 1
elif site.type == "a":
prot_state = 0
possible_states_occ[isite].append(prot_state)
possible_states_g[isite].append(0.0)
maxstates = max(Config.parallel_params.npossible_states)
interactions_look = Config.parallel_params.interactions_look
# resize_list_of_lists(possible_states, maxstates)
resize_list_of_lists(possible_states_g, maxstates)
resize_list_of_lists(possible_states_occ, maxstates, filler=-500)
resize_list_of_lists(interactions_look, maxstates, filler=-500)
params = Config.mc_params
pHmin, pHmax = params["pHmin"], params["pHmax"]
dpH = params["pHstep"]
pHsteps = int(round(1 + (pHmax - pHmin) / dpH, 0))
Config.parallel_params.possible_states_g = possible_states_g
Config.parallel_params.possible_states_occ = possible_states_occ
ncpus = min(Config.pypka_params["ncpus"], nsites)
results = startPoolProcesses(
runMCCalcs,
list(range(pHsteps)),
ncpus,
assign="ordered",
merged_results=True,
)
print("\rMC Runs Ended{:>80}\n".format(""))
counts_all = []
avgs_all = []
cur_states = []
for i in results:
avgs_all.append(i[0])
counts_all.append(i[1])
cur_states.append(i[3])
pKs = np.array([[PKAPLACEHOLDER for ii in range(MAXNPKHALFS)]
for i in range(nsites)])
mcsteps = params["mcsteps"]
pmeans = avgs_all[0] / float(mcsteps)
tit_curve = {}
tit_curve[pHmin] = {}
tit_curve[pHmin]["total"] = sum(avgs_all[0]) / mcsteps / nsites
for i, mean in enumerate(avgs_all[0]):
site = sites[i]
sitenumber = site.res_number
tit_curve[pHmin][sitenumber] = mean / mcsteps
sites = Config.parallel_params.all_sites
for pHstep in range(1, pHsteps):
pH = pHmin + pHstep * dpH
totalP, pKs, pmeans, means = calcpKhalfs(pH, nsites,
avgs_all[pHstep], pmeans,
pKs, mcsteps, dpH)
tit_curve[pH] = {}
tit_curve[pH]["total"] = totalP
for i, mean in enumerate(means):
site = sites[i]
sitenumber = site.res_number
tit_curve[pH][sitenumber] = mean
pKas = pKs
text_pks = ""
text_prots = "#pH total"
c = -1
for i in pKas:
c += 1
site = sites[c]
chain = site.molecule.chain
sitename = site.getName()
resnumb = site.getResNumber()
if sitename in ("NTR", "CTR"):
text_prots += " {0:3}".format(sitename)
else:
text_prots += "{0:5d}{1:3s}".format(resnumb, sitename)
text_pks += "{0:5} {1:3} {2:20} {3:3}\n".format(
resnumb, sitename, str(i[0]), chain)
final_states = {}
state_distribution = {}
most_prob_states = {}
self.tit_curve = {}
for pHstep in range(pHsteps):
pH = pHmin + pHstep * dpH
text_prots += "\n{pH:5.2f}".format(pH=pH)
self.tit_curve[pH] = tit_curve[pH]["total"]
final_states[pH] = {}
state_distribution[pH] = {}
most_prob_states[pH] = {}
for c, site in enumerate(sites):
sitename = site.getName()
sitenumb = site.res_number
mean = tit_curve[pH][sitenumb]
final_states[pH][sitenumb] = cur_states[pHstep][c]
state_distribution[pH][sitenumb] = list(counts_all[pHstep][c] /
mcsteps)
ntauts = site.getNTautomers()
ref_i = ntauts
prot_state = site.getRefProtState()
if (mean > 0.5 and prot_state == 1) or (mean <= 0.5
and prot_state == -1):
state_i = ref_i
else:
max_prob = max(state_distribution[pH][sitenumb][:ref_i])
state_i = state_distribution[pH][sitenumb].index(max_prob)
most_prob_state = state_i + 1
most_prob_states[pH][sitenumb] = most_prob_state
if mean != PKAPLACEHOLDER:
text_prots += "\t{mean:7.4f}".format(mean=mean)
else:
text_prots += "\t-"
site.most_prob_states[pH] = most_prob_state
site.final_states[pH] = final_states[pH][sitenumb]
site.tit_curve[pH] = tit_curve[pH][sitenumb]
site.states_prob[pH] = state_distribution[pH][sitenumb]
if Config.pypka_params["f_out"]:
with open(Config.pypka_params["f_out"], "w") as f:
f.write(text_pks)
if Config.pypka_params["f_prot_out"]:
with open(Config.pypka_params["f_prot_out"], "w") as f:
f.write(text_prots)
# self.tit_curve = tit_curve
# self.pH_values = sorted(tit_curve.keys())
# self.final_states = final_states
# self.state_prob = state_distribution
# self.most_prob_states = most_prob_states
c = -1
for i in pKas:
c += 1
# site = sites[c].res_number
# chain = sites[c].molecule.chain
# if chain not in self.pKas.keys():
# self.pKas[chain] = {}
pK = i[0]
sites[c].setpK(pK)
def calcSiteInteractionsParallel(self):
"""Calculates the pairwise interaction energies
and writes them in a formatted .dat file
Interactions are calculated using a pool of processes
Args:
ncpus (int): number of cpus to be used
"""
def writeDatHeader(sites):
"""Writes pKint energies in .dat file header"""
to_write = "{0}\n".format(len(sites))
for site in sites:
to_write += "{0:3s}-{1:<7}{2:>2} P *\n".format(
site.res_name, site.res_number,
len(site.tautomers) + 1)
if site.type == "c":
tau_prot_state = 0
ref_prot_state = 1
elif site.type == "a":
tau_prot_state = 1
ref_prot_state = 0
for tautomer in site.iterOrderedTautomersWithoutRef():
to_write += "{0:1d} {1:13.6e}\n".format(
tau_prot_state, tautomer.dg)
to_write += "{0:1d} 0.000000e+00\n".format(ref_prot_state)
if Config.debug:
with open("interactions.dat", "w") as f_new:
f_new.write(to_write)
Config.loadParams(self.__parameters)
sites = self.get_all_sites(get_list=True)
if Config.debug:
writeDatHeader(sites)
counter = 0
site_interactions = []
for site1 in sites[:-1]:
counter += 1
for site2 in sites[counter:]:
site_interactions.append((site1, site2))
npossible_states = [len(site.tautomers) + 1 for site in sites]
Config.parallel_params.npossible_states = npossible_states
interactions = []
for nstate1 in range(sum(npossible_states)):
interactions.append([])
for _ in range(sum(npossible_states)):
interactions[nstate1].append(-999999)
interactions_look = []
aux = -1
site = -1
for nstates in npossible_states:
site += 1
interactions_look.append([])
for _ in range(nstates):
aux += 1
interactions_look[site].append(aux)
Config.parallel_params.interactions_look = interactions_look
Config.parallel_params.site_interactions = site_interactions
Config.parallel_params.all_sites = sites
Config.parallel_params.interactions = interactions
ncpus = min(len(site_interactions), Config.pypka_params["ncpus"])
results = []
if ncpus > 0:
results = startPoolProcesses(
runInteractionCalcs,
site_interactions,
ncpus,
assign="ordered",
merged_results=True,
)
interactions = Config.parallel_params.interactions
to_write = ""
temperature = float(Config.pypka_params["temp"])
for interaction in results:
site1i = interaction[0]
site2i = interaction[1]
if interactions[site1i][site2i] != -999999:
interactions[site1i][site2i] += interaction[2]
interactions[site2i][site1i] += interaction[2]
interactions[site1i][site2i] /= 2
interactions[site2i][site1i] /= 2
if Config.debug:
col1 = interaction[3][6:18]
col2 = interaction[3][:6]
col3 = interactions[site1i][site2i] * (KBOLTZ *
temperature)
to_write += "{0}{1} {2:13.6e}\n".format(col1, col2, col3)
else:
interactions[site1i][site2i] = interaction[2]
interactions[site2i][site1i] = interaction[2]
if Config.debug:
with open("interactions.dat", "a") as f_new:
f_new.write(to_write)