def read_trajectory(self):
if(not path.exists(self.trr_fn)):
raise(Exception("%s not found."%self.trr_fn))
if(self.__dict__.has_key("_trajectory_cache") and self.__dict__["_trajectory_cache_time"] >= path.getmtime(self.trr_fn)):
#print "Using trajectory cache."
return(self._trajectory_cache)
# using print for newline, so that converter warnings are more readable
#sys.stdout.write("Loading trr-file: %s... "%self.trr_fn)
#sys.stdout.flush()
print("Loading trr-file: %s... "%self.trr_fn)
frames_int = self.pool.converter.read_trajectory(self.trr_fn)
print("done.")
if(self.has_internals and self.has_restraints):
phi_values = get_phi(frames_int, self)
penalty_potential = np.zeros(frames_int.n_frames)
for (r, c) in zip(self.restraints, self.pool.converter):
penalty_potential += r.energy(frames_int[:,c])
beta = self.pool.thermo_beta
frameweights = phi_values / np.exp(-beta * penalty_potential)
else:
phi_values = np.zeros(frames_int.n_frames)
penalty_potential = np.zeros(frames_int.n_frames)
frameweights = np.ones(frames_int.n_frames)
trajectory = InternalArray(frames_int.converter, frames_int.array, frameweights)
self.__dict__["_phi_values_cache"] = phi_values
self.__dict__["_penalty_potential_cache"] = penalty_potential
self.__dict__["_trajectory_cache"] = trajectory
self.__dict__["_trajectory_cache_time"] = path.getmtime(self.trr_fn)
return(self._trajectory_cache)
def get_phi_mat(ints, nodes):
"caclculates the membership of every frame to every node"
phi = np.empty((ints.n_frames, len(nodes)))
for j in xrange(len(nodes)):
phi[:, j] = get_phi(ints, nodes[j])
return phi
def get_phi_mat (ints, nodes): "caclculates the membership of every frame to every node" phi = np.empty((ints.n_frames, len(nodes))) for j in xrange(len(nodes)): phi[:,j] = get_phi(ints, nodes[j]) return phi
def reweight_presampling(nodes, presamp_temp, moi_energies, sol_energy):
print "Presampling analysis reweighting: see formula 18 in Fackeldey, Durmaz, Weber 2011"
# presampling data
presampling_internals = nodes[0].pool.root.trajectory # alternatively pool[0].trajectory
# presampling and sampling beta
beta_samp = nodes[0].pool.thermo_beta
beta_presamp = 1/(presamp_temp*BOLTZMANN*AVOGADRO)
# calculate free energy per node
for n in nodes:
log = open(n.reweighting_log_fn, "a") # using separate log-file
def output(message):
print(message)
log.write(message+"\n")
output("======= Starting node reweighting %s"%datetime.now())
# get potential V and substract penalty potential
energies = load_energies(n, with_penalty=False, with_sol=sol_energy, with_moi_energies=moi_energies)
frame_weights = n.frameweights
phi_values = n.phi_values
phi_weighted_energies = energies + get_phi_potential(n.trajectory, n)
# calculate mean V and standard deviation
n.obs.mean_V = np.average(phi_weighted_energies, weights=frame_weights)
n.tmp['weight'] = 1.0
n.obs.std_V = np.sqrt(np.average(np.square(phi_weighted_energies - n.obs.mean_V), weights=frame_weights))
# number of presampling points in node i => free energy at high temperature
n.tmp['presamp_weight'] = np.sum(get_phi(presampling_internals, n))
n.tmp['presamp_A']= -1/beta_presamp * np.log(n.tmp['presamp_weight'])
# estimate global optimum potential energy
factor= 1.0
n.tmp['opt_pot_energy']= n.obs.mean_V - 3.0 * factor * n.obs.std_V
# compute free energy and entropy at sampling temperature
n.obs.S = 0.0 #TODO can we get separate entropy from the term below?
n.obs.A = (beta_samp - beta_presamp) / beta_samp * n.tmp['opt_pot_energy'] + np.log(beta_samp / beta_presamp) * factor * n.obs.std_V + (beta_presamp / beta_samp) * n.tmp['presamp_A']
if('refpoints' in n.obs):
del n.obs['refpoints']
log.close()
nodes.sort(key = lambda n: n.obs.A) # sort in ascending order by free energy values
for (n1, n2) in zip(nodes[1:], nodes[:-1]): # calculate and normalize weights
n1.tmp['weight'] = np.exp(-nodes[0].pool.thermo_beta*( n1.obs.A - n2.obs.A )) * n2.tmp['weight']
def calc_matrix(nodes, shift=0, cache_denom=False):
mat = np.zeros( (len(nodes), len(nodes)) )
for (i, ni) in enumerate(nodes):
print("Working on: %s"%ni)
if(cache_denom):
phi_denom = get_phi_denom(ni.trajectory, nodes)
frame_weights = ni.frameweights
if shift > 0:
frame_weights = frame_weights[:-shift]
for (j, nj) in enumerate(nodes):
if(cache_denom):
mat[i, j] = np.average(get_phi_num(ni.trajectory, nj)[shift:] / phi_denom[shift:], weights=frame_weights)
else:
mat[i, j] = np.average(get_phi(ni.trajectory, nj)[shift:], weights=frame_weights)
return(mat)
def read_trajectory(self):
if (not path.exists(self.trr_fn)):
raise (Exception("%s not found." % self.trr_fn))
if (self.__dict__.has_key("_trajectory_cache")
and self.__dict__["_trajectory_cache_time"] >= path.getmtime(
self.trr_fn)):
#print "Using trajectory cache."
return (self._trajectory_cache)
# using print for newline, so that converter warnings are more readable
#sys.stdout.write("Loading trr-file: %s... "%self.trr_fn)
#sys.stdout.flush()
print("Loading trr-file: %s... " % self.trr_fn)
frames_int = self.pool.converter.read_trajectory(self.trr_fn)
print("done.")
if (self.has_internals and self.has_restraints):
phi_values = get_phi(frames_int, self)
penalty_potential = np.zeros(frames_int.n_frames)
for (r, c) in zip(self.restraints, self.pool.converter):
penalty_potential += r.energy(frames_int[:, c])
beta = self.pool.thermo_beta
frameweights = phi_values / np.exp(-beta * penalty_potential)
else:
phi_values = np.zeros(frames_int.n_frames)
penalty_potential = np.zeros(frames_int.n_frames)
frameweights = np.ones(frames_int.n_frames)
trajectory = InternalArray(frames_int.converter, frames_int.array,
frameweights)
self.__dict__["_phi_values_cache"] = phi_values
self.__dict__["_penalty_potential_cache"] = penalty_potential
self.__dict__["_trajectory_cache"] = trajectory
self.__dict__["_trajectory_cache_time"] = path.getmtime(self.trr_fn)
return (self._trajectory_cache)
