def main(argv=None):
if(argv==None):
argv = sys.argv
options = options_desc.parse_args(argv)[0]
assert(not(options.refine_all and options.extend_all))
pool = Pool()
needy_nodes = pool.where("isa_partition and is_sampled").multilock()
# 1. Trying to detect fake convergence
for n in pool.where("state == 'converged'"):
means = kmeans(n.trajectory, k=2)
d = (means[0] - means[1]).norm2()
if(d > 2.0 and (options.refine_all or userinput("%s has converged but appears to have a bimodal distribution.\nDo you want to refine?"%n.name, "bool"))): #TODO decide upon threshold (per coordinate?)
refine(n, options)
# 2. Dealing with not-converged nodes
for n in pool.where("state == 'not-converged'"):
if(not(options.refine_all or options.extend_all)):
choice = userchoice("%s has not converged. What do you want to do?"%n.name, ['_refine', '_extend', '_ignore'])
if(options.refine_all or choice=="r"):
refine(n, options)
elif(options.extend_all or choice=="e"):
extend(n)
elif(choice=="i"):
continue
for n in needy_nodes:
n.save()
n.unlock()
zgf_setup_nodes.main()
zgf_grompp.main()
zgf_cleanup.main()
def main():
pool = Pool()
if(len(pool.where("state == 'grompp-able'")) > 0):
call_grompp(pool)
if(len(pool.where("state == 'em-grompp-able'")) > 0):
assert(path.exists("em.mdp")) #TODO that's not super nice yet
call_grompp(pool, mode='em')
def main():
options = options_desc.parse_args(sys.argv)[0]
zgf_cleanup.main()
pool = Pool()
not_reweightable = "isa_partition and state not in ('converged'"
if (options.ignore_convergence):
not_reweightable += ",'not-converged'"
if (options.ignore_failed):
not_reweightable += ",'mdrun-failed'"
not_reweightable += ")"
if pool.where(not_reweightable):
print "Pool can not be reweighted due to the following nodes:"
for bad_guy in pool.where(not_reweightable):
print "Node %s with state %s." % (bad_guy.name, bad_guy.state)
sys.exit("Aborting.")
active_nodes = pool.where("isa_partition and state != 'mdrun-failed'")
assert (len(active_nodes) == len(active_nodes.multilock())
) # make sure we lock ALL nodes
if (options.check_restraint):
for n in active_nodes:
check_restraint_energy(n)
if (options.method == "direct"):
reweight_direct(active_nodes, options)
elif (options.method == "entropy"):
reweight_entropy(active_nodes, options)
elif (options.method == "presampling"):
reweight_presampling(active_nodes, options)
else:
raise (Exception("Method unkown: " + options.method))
weight_sum = np.sum([n.tmp['weight'] for n in active_nodes])
print "Thermodynamic weights calculated by method '%s':" % options.method
for n in active_nodes:
n.obs.weight_direct = n.tmp['weight'] / weight_sum
if (options.method == "direct"):
print(
" %s with mean_V: %f [kJ/mol], %d refpoints and weight: %f" %
(n.name, n.obs.mean_V, n.tmp['n_refpoints'],
n.obs.weight_direct))
else:
print(" %s with A: %f [kJ/mol] and weight: %f" %
(n.name, n.obs.A, n.obs.weight_direct))
print "The above weighting uses bonded energies='%s' and nonbonded energies='%s'." % (
options.e_bonded, options.e_nonbonded)
for n in active_nodes:
n.save()
active_nodes.unlock()
def main():
options = options_desc.parse_args(sys.argv)[0]
zgf_cleanup.main()
pool = Pool()
#not_reweightable = "state not in ('refined','converged')"
not_reweightable = "isa_partition and state!='converged'"
if options.ignore_convergence:
not_reweightable = "isa_partition and state not in ('converged','not-converged')"
if pool.where(not_reweightable):
print "Pool can not be reweighted due to the following nodes:"
for bad_guy in pool.where(not_reweightable):
print "Node %s with state %s."%(bad_guy.name, bad_guy.state)
sys.exit("Aborting.")
active_nodes = pool.where("isa_partition")
assert(len(active_nodes) == len(active_nodes.multilock())) # make sure we lock ALL nodes
for n in active_nodes:
check_restraint_energy(n)
# find out about number of energygrps
mdp_file = gromacs.read_mdp_file(pool.mdp_fn)
energygrps = [str(egrp) for egrp in re.findall('[\S]+', mdp_file["energygrps"])]
moi_energies = True
if len(energygrps) < 2:
moi_energies = False # Gromacs energies are named differently when there are less than two energygrps :(
if(options.method == "direct"):
reweight_direct(active_nodes, moi_energies, options.sol_energy, options.save_refpoints)
elif(options.method == "entropy"):
reweight_entropy(active_nodes, moi_energies, options.sol_energy, options.save_refpoints)
elif(options.method == "presampling"):
reweight_presampling(active_nodes, options.presamp_temp, moi_energies, options.sol_energy)
else:
raise(Exception("Method unkown: "+options.method))
weight_sum = np.sum([n.tmp['weight'] for n in active_nodes])
print "Thermodynamic weights calculated by method '%s' (sol-energy=%s):"%(options.method, options.sol_energy)
for n in active_nodes:
n.obs.weight_direct = n.tmp['weight'] / weight_sum
if(options.method == "direct"):
print(" %s with mean_V: %f [kJ/mol], %d refpoints and weight: %f" % (n.name, n.obs.mean_V, n.tmp['n_refpoints'], n.obs.weight_direct))
else:
print(" %s with A: %f [kJ/mol] and weight: %f" % (n.name, n.obs.A, n.obs.weight_direct))
for n in active_nodes:
n.save()
active_nodes.unlock()
def main():
options = options_desc.parse_args(sys.argv)[0]
zgf_cleanup.main()
pool = Pool()
not_reweightable = "isa_partition and state not in ('converged'"
if(options.ignore_convergence):
not_reweightable += ",'not-converged'"
if(options.ignore_failed):
not_reweightable += ",'mdrun-failed'"
not_reweightable += ")"
if pool.where(not_reweightable):
print "Pool can not be reweighted due to the following nodes:"
for bad_guy in pool.where(not_reweightable):
print "Node %s with state %s."%(bad_guy.name, bad_guy.state)
sys.exit("Aborting.")
active_nodes = pool.where("isa_partition and state != 'mdrun-failed'")
assert(len(active_nodes) == len(active_nodes.multilock())) # make sure we lock ALL nodes
if(options.check_restraint):
for n in active_nodes:
check_restraint_energy(n)
if(options.method == "direct"):
reweight_direct(active_nodes, options)
elif(options.method == "entropy"):
reweight_entropy(active_nodes, options)
elif(options.method == "presampling"):
reweight_presampling(active_nodes, options)
else:
raise(Exception("Method unkown: "+options.method))
weight_sum = np.sum([n.tmp['weight'] for n in active_nodes])
print "Thermodynamic weights calculated by method '%s':"%options.method
for n in active_nodes:
n.obs.weight_direct = n.tmp['weight'] / weight_sum
if(options.method == "direct"):
print(" %s with mean_V: %f [kJ/mol], %d refpoints and weight: %f" % (n.name, n.obs.mean_V, n.tmp['n_refpoints'], n.obs.weight_direct))
else:
print(" %s with A: %f [kJ/mol] and weight: %f" % (n.name, n.obs.A, n.obs.weight_direct))
print "The above weighting uses bonded energies='%s' and nonbonded energies='%s'."%(options.e_bonded, options.e_nonbonded)
for n in active_nodes:
n.save()
active_nodes.unlock()
def main():
options = options_desc.parse_args(sys.argv)[0]
pool = Pool()
choice = "state in ('converged', 'refined')"
if (options.ignore_convergence):
choice = "state in ('converged', 'not-converged', 'refined')"
needy_nodes = NodeList([
n for n in pool.where(choice) if not n == pool.root
]) # we won't touch the root
if not (len(needy_nodes)):
sys.exit("Nothing to do.")
if not (userinput(
"Once the solvent has been removed, further refinement of the pool is not possible. This includes the generation of unrestrained transition nodes! Continue?",
"bool")):
sys.exit("Quit by user.")
assert (len(needy_nodes) == len(needy_nodes.multilock())
) # make sure we lock ALL nodes
try:
for n in needy_nodes:
discard_solvent(n, "pdb")
discard_solvent(n, "trr")
for n in needy_nodes:
n.unlock()
except:
traceback.print_exc()
def main():
options = options_desc.parse_args(sys.argv)[0]
pool = Pool()
choice = "state in ('converged', 'refined')"
if(options.ignore_convergence):
choice = "state in ('converged', 'not-converged', 'refined')"
needy_nodes = NodeList([n for n in pool.where(choice) if not n == pool.root]) # we won't touch the root
if not(len(needy_nodes)):
sys.exit("Nothing to do.")
if not(userinput("Once the solvent has been removed, further refinement of the pool is not possible. This includes the generation of unrestrained transition nodes! Continue?", "bool")):
sys.exit("Quit by user.")
assert(len(needy_nodes) == len(needy_nodes.multilock())) # make sure we lock ALL nodes
try:
for n in needy_nodes:
discard_solvent(n, "pdb")
discard_solvent(n, "trr")
for n in needy_nodes:
n.unlock()
except:
traceback.print_exc()
def main():
options = options_desc.parse_args(sys.argv)[0]
pool = Pool()
needy_nodes = pool.where("state == 'merge-able'").multilock()
if(len(needy_nodes) == 0):
return
# find out about trr time step
dt = 0
nodeDir = needy_nodes[0].dir.split('/')[-1]
for fn in os.listdir(needy_nodes[0].dir):
if re.match("^"+nodeDir+".+run\d+\.trr", fn):
trr = TrrFile(needy_nodes[0].dir+"/"+fn)
dt = trr.first_frame.next().t - trr.first_frame.t
trr.close()
break
# dt is sometimes noisy in the final digits (three digits is femtosecond step = enough)
dt = np.around(dt, decimals=3)
for n in needy_nodes:
if(options.trr):
# merge sampling trajectories
trr_fns = sorted([ fn for fn in os.listdir(n.dir) if re.match("[^#].+run\d+.trr", fn) ])
cmd = ["trjcat", "-f"]
cmd += trr_fns
cmd += ["-o", "../../"+n.trr_fn, "-cat"]
print("Calling: %s"%" ".join(cmd))
check_call(cmd, cwd=n.dir)
if(options.edr):
# merge edr files
# get list of edr-files
edr_fnames = sorted([n.dir+"/"+fn for fn in os.listdir(n.dir) if re.match("[^#].+run\d+.edr", fn)])
assert( len(edr_fnames) == n.extensions_counter+1 )
assert( len(edr_fnames) == n.extensions_max+1 )
time_offset = n.sampling_length+dt
for edr_fn in edr_fnames[1:]:
# adapt edr starting times
cmd = ["eneconv", "-f", edr_fn, "-o", edr_fn, "-settime"]
print("Calling: "+(" ".join(cmd)))
p = Popen(cmd, stdin=PIPE)
p.communicate(input=(str(time_offset)+"\n"))
assert(p.wait() == 0)
time_offset += n.extensions_length+dt
# concatenate edr files with adapted starting times
cmd = ["eneconv", "-f"] + edr_fnames + ["-o", n.dir+"/ener.edr"]
print("Calling: "+(" ".join(cmd)))
p = Popen(cmd)
retcode = p.wait()
assert(retcode == 0)
needy_nodes.unlock()
def main():
options = options_desc.parse_args(sys.argv)[0]
pool = Pool()
if(options.convtest):
for n in pool.where("state in ('converged', 'not-converged')"):
print("\n\nRunning Gelman-Rubin on %s"%n)
conv_check_gelman_rubin(n)
return # exit
auto_refines_counter = 0
while(True):
pool.reload()
pool.reload_nodes()
for n in pool:
n.reload()
active_node = None
for n in pool.where("state in ('em-mdrun-able', 'mdrun-able', 'rerun-able-converged', 'rerun-able-not-converged')"):
if(n.lock()):
active_node = n
break
if(active_node == None):
if(auto_refines_counter < options.auto_refines):
auto_refines_counter += 1
print("\n\nRunning 'zgf_refine --refine-all' for the %d time..."%auto_refines_counter)
zgf_refine.main(["--refine-all"])
continue
else:
break # we're done - exit
try:
process(active_node, options)
active_node.save()
active_node.unlock()
except:
print "MDRUN FAILED"
active_node.state = "mdrun-failed"
active_node.save()
active_node.unlock()
traceback.print_exc()
continue
def main():
pool = Pool()
needy_nodes = pool.where("state == 'grompp-able'").multilock()
try:
for n in needy_nodes:
call_grompp(n)
except:
traceback.print_exc()
for n in needy_nodes:
n.unlock()
def main():
pool = Pool()
needy_nodes = pool.where("state == 'grompp-able'").multilock()
try:
for n in needy_nodes:
call_grompp(n)
except:
traceback.print_exc()
for n in needy_nodes:
n.unlock()
def main():
options = options_desc.parse_args(sys.argv)[0]
pool = Pool()
needy_nodes = pool.where("state == 'grompp-able'")
assert (len(needy_nodes) == len(needy_nodes.multilock())
) # make sure we lock ALL nodes
if (options.solv_model == "tip3p"):
solv_box = "spc216.gro"
solv_fn = "tip3p.itp"
elif (options.solv_model == "tip4p"):
solv_box = "tip4p.gro"
solv_fn = "tip4p.itp"
elif (options.solv_model == "tip4pew"):
solv_box = "tip4p.gro"
solv_fn = "tip4pew.itp"
elif (options.solv_model == "tip5"):
solv_box = "tip5p.gro"
solv_fn = "tip5p.itp"
elif (options.solv_model == "spc"):
solv_box = "spc216.gro"
solv_fn = "spc.itp"
elif (options.solv_model == "spce"):
solv_box = "spc216.gro"
solv_fn = "spce.itp"
elif (
options.solv_model == "acetonitrile"
): # TODO one might change this one to "custom" and let user enter name of template box
solv_box = "acetonitrile.pdb"
msg = "Topology update for acetonitrile is not supported. Proceed?"
if not (userinput(msg, "bool")):
for n in needy_nodes:
n.unlock()
return ("Quit by user.")
# determine maximum length of linears, if any
max_linear = query_linear_length(pool)
# make box and fill with solvent
genbox(pool, max_linear, options.bt,
(options.box_x, options.box_y, options.box_z), solv_box)
# update topology files (add solvent model and ions includes)
if not (options.solv_model == "acetonitrile"):
update_tops(pool, solv_fn)
for n in needy_nodes:
n.state = "em-grompp-able"
zgf_grompp.call_grompp(
n, mdp_file=options.grompp, final_state="em-mdrun-able"
) # re-grompp to get a tpr for energy minimization
n.unlock()
def main(argv=None):
if (argv == None):
argv = sys.argv
options = options_desc.parse_args(argv)[0]
assert (not (options.refine_all and options.extend_all))
pool = Pool()
needy_nodes = pool.where("isa_partition and is_sampled").multilock()
# 1. Trying to detect fake convergence
for n in pool.where("state == 'converged'"):
means = kmeans(n.trajectory, k=2)
d = (means[0] - means[1]).norm2()
if (d > 2.0 and (options.refine_all or userinput(
"%s has converged but appears to have a bimodal distribution.\nDo you want to refine?"
% n.name,
"bool"))): #TODO decide upon threshold (per coordinate?)
refine(n, options)
# 2. Dealing with not-converged nodes
for n in pool.where("state == 'not-converged'"):
if (not (options.refine_all or options.extend_all)):
choice = userchoice(
"%s has not converged. What do you want to do?" % n.name,
['_refine', '_extend', '_ignore'])
if (options.refine_all or choice == "r"):
refine(n, options)
elif (options.extend_all or choice == "e"):
extend(n)
elif (choice == "i"):
continue
for n in needy_nodes:
n.save()
n.unlock()
zgf_setup_nodes.main()
zgf_grompp.main()
zgf_cleanup.main()
def main():
options = options_desc.parse_args(sys.argv)[0]
#TODO put somehow into Options, e.g. min_value=1 or required=True
if(not options.doomed_nodes):
sys.exit("Option --doomed_nodes is required.")
pool = Pool()
old_pool_size = len(pool)
old_alpha = pool.alpha
doomed_nodes = NodeList()
#TODO: maybe this code should go into ZIBMolPy.ui
for name in options.doomed_nodes.split(","):
found = [n for n in pool if n.name == name]
if(len(found) != 1):
sys.exit("Coult not find node '%s'"%(name))
doomed_nodes.append(found[0])
for n in doomed_nodes:
if(n == pool.root):
sys.exit("Node %s is the root. Removal not allowed."%(n.name))
#if(len(n.children) > 0):
# sys.exit("Node %s has children. Removal not allowed."%(n.name)) #TODO why should we forbid this?
if not(userinput("The selected node(s) will be removed permanently. Continue?", "bool")):
sys.exit("Quit by user.")
assert(len(doomed_nodes) == len(doomed_nodes.multilock()))
for n in doomed_nodes:
print("Removing directory: "+n.dir)
shutil.rmtree(n.dir)
pool.reload_nodes()
#TODO: this code-block also exists in zgf_create_node
if(len(pool.where("isa_partition")) < 2):
pool.alpha = None
elif(options.methodalphas == "theta"):
pool.alpha = zgf_create_nodes.calc_alpha_theta(pool)
elif(options.methodalphas == "user"):
pool.alpha = userinput("Please enter a value for alpha", "float")
else:
raise(Exception("Method unkown: "+options.methodalphas))
pool.history.append({'removed_nodes': [(n.name, n.state) for n in doomed_nodes], 'size':old_pool_size, 'alpha':old_alpha, 'timestamp':datetime.now()})
pool.save()
#TODO: deal with analysis dir and dependencies
zgf_cleanup.main()
def main():
options = options_desc.parse_args(sys.argv)[0]
#TODO put somehow into Options, e.g. min_value=1 or required=True
if(not options.doomed_nodes):
sys.exit("Option --doomed_nodes is required.")
pool = Pool()
old_pool_size = len(pool)
old_alpha = pool.alpha
doomed_nodes = NodeList()
#TODO: maybe this code should go into ZIBMolPy.ui
for name in options.doomed_nodes.split(","):
found = [n for n in pool if n.name == name]
if(len(found) != 1):
sys.exit("Coult not find node '%s'"%(name))
doomed_nodes.append(found[0])
for n in doomed_nodes:
if(n == pool.root):
sys.exit("Node %s is the root. Removal not allowed."%(n.name))
#if(len(n.children) > 0):
# sys.exit("Node %s has children. Removal not allowed."%(n.name)) #TODO why should we forbid this?
if not(userinput("The selected node(s) will be removed permanently. Continue?", "bool")):
sys.exit("Quit by user.")
assert(len(doomed_nodes) == len(doomed_nodes.multilock()))
for n in doomed_nodes:
print("Removing directory: "+n.dir)
shutil.rmtree(n.dir)
pool.reload_nodes()
#TODO: this code-block also exists in zgf_create_node
if(len(pool.where("isa_partition")) < 2):
pool.alpha = None
elif(options.methodalphas == "theta"):
pool.alpha = zgf_create_nodes.calc_alpha_theta(pool)
elif(options.methodalphas == "user"):
pool.alpha = userinput("Please enter a value for alpha", "float")
else:
raise(Exception("Method unkown: "+options.methodalphas))
pool.history.append({'removed_nodes': [(n.name, n.state) for n in doomed_nodes], 'size':old_pool_size, 'alpha':old_alpha, 'timestamp':datetime.now()})
pool.save()
#TODO: deal with analysis dir and dependencies
zgf_cleanup.main()
def main():
pool = Pool()
needy_nodes = pool.where("state == 'created'")
assert(len(needy_nodes) == len(needy_nodes.multilock())) # make sure we lock ALL nodes
extract_frames(pool)
generate_topology(pool)
generate_mdp(pool)
for n in needy_nodes:
n.state = "grompp-able"
n.save()
n.unlock()
def main():
options = options_desc.parse_args(sys.argv)[0]
zgf_cleanup.main()
pool = Pool()
needy_nodes = pool.where("state == '%s'"%options.current_state).multilock()
for n in needy_nodes:
print "Recovering node %s with state %s to state %s ..."%(n.name, n.state, options.recover_state)
n.state = options.recover_state
n.save()
n.unlock()
def main():
pool = Pool()
needy_nodes = pool.where("state == 'created'")
assert (len(needy_nodes) == len(needy_nodes.multilock())
) # make sure we lock ALL nodes
extract_frames(pool)
generate_topology(pool)
generate_mdp(pool)
for n in needy_nodes:
n.state = "grompp-able"
n.save()
n.unlock()
def main():
options = options_desc.parse_args(sys.argv)[0]
zgf_cleanup.main()
pool = Pool()
needy_nodes = pool.where("state == '%s'" %
options.current_state).multilock()
for n in needy_nodes:
print "Recovering node %s with state %s to state %s ..." % (
n.name, n.state, options.recover_state)
n.state = options.recover_state
n.save()
n.unlock()
def main():
options = options_desc.parse_args(sys.argv)[0]
outfile = open(options.outfile,"w")
pool = Pool()
needy_nodes = pool.where("isa_partition and state not in ('refined','mdrun-failed')")
for n in needy_nodes:
outfile.write("%s, state: '%s':\n"%(n.name,n.state))
outfile.write(str(n.internals.array)+"\n")
outfile.write("mean pot.: %f, std pot.: %f, free energy estimate: %f\n"%(n.obs.mean_V,n.obs.std_V,n.obs.A))
outfile.write("#========================================================================#\n")
outfile.close()
print "Pool info was written to %s."%options.outfile
def main():
options = options_desc.parse_args(sys.argv)[0]
pool = Pool()
needy_nodes = pool.where("state == 'em-mdrun-able'")
assert(len(needy_nodes) == len(needy_nodes.multilock())) # make sure we lock ALL nodes
# add ions to simulation boxes
call_genion(pool, options.np, options.pname, options.nn, options.nname, options.random_seed)
for n in needy_nodes:
n.state = "em-grompp-able"
zgf_grompp.call_grompp(n, mdp_file=options.grompp, final_state="em-mdrun-able") # re-grompp to get a tpr for energy minimization
n.unlock()
def main():
options = options_desc.parse_args(sys.argv)[0]
pool = Pool()
needy_nodes = pool.where("state == 'grompp-able'")
assert(len(needy_nodes) == len(needy_nodes.multilock())) # make sure we lock ALL nodes
if(options.solv_model == "tip3p"):
solv_box = "spc216.gro"
solv_fn = "tip3p.itp"
elif(options.solv_model == "tip4p"):
solv_box = "tip4p.gro"
solv_fn = "tip4p.itp"
elif(options.solv_model == "tip4pew"):
solv_box = "tip4p.gro"
solv_fn = "tip4pew.itp"
elif(options.solv_model == "tip5"):
solv_box = "tip5p.gro"
solv_fn = "tip5p.itp"
elif(options.solv_model == "spc"):
solv_box = "spc216.gro"
solv_fn = "spc.itp"
elif(options.solv_model == "spce"):
solv_box = "spc216.gro"
solv_fn = "spce.itp"
elif(options.solv_model == "acetonitrile"): # TODO one might change this one to "custom" and let user enter name of template box
solv_box = "acetonitrile.pdb"
msg = "Topology update for acetonitrile is not supported. Proceed?"
if not(userinput(msg, "bool")):
for n in needy_nodes:
n.unlock()
return("Quit by user.")
# determine maximum length of linears, if any
max_linear = query_linear_length(pool)
# make box and fill with solvent
genbox(pool, max_linear, options.bt, (options.box_x, options.box_y, options.box_z), solv_box)
# update topology files (add solvent model and ions includes)
if not(options.solv_model == "acetonitrile"):
update_tops(pool, solv_fn)
for n in needy_nodes:
n.state = "em-grompp-able"
zgf_grompp.call_grompp(n, mdp_file=options.grompp, final_state="em-mdrun-able") # re-grompp to get a tpr for energy minimization
n.unlock()
def main():
options = options_desc.parse_args(sys.argv)[0]
pool = Pool()
needy_nodes = pool.where("state == 'em-mdrun-able'")
assert(len(needy_nodes) == len(needy_nodes.multilock())) # make sure we lock ALL nodes
# add ions to simulation boxes
call_genion(pool, options.np, options.pname, options.nn, options.nname, options.random_seed)
for n in needy_nodes:
n.state = "em-grompp-able"
n.save()
n.unlock()
zgf_grompp.main()
def main():
options = options_desc.parse_args(sys.argv)[0]
pool = Pool()
needy_nodes = pool.where("state == 'em-mdrun-able'")
assert (len(needy_nodes) == len(needy_nodes.multilock())
) # make sure we lock ALL nodes
# add ions to simulation boxes
call_genion(pool, options.np, options.pname, options.nn, options.nname,
options.random_seed)
for n in needy_nodes:
n.state = "em-grompp-able"
zgf_grompp.call_grompp(
n, mdp_file=options.grompp, final_state="em-mdrun-able"
) # re-grompp to get a tpr for energy minimization
n.unlock()
def main():
options = options_desc.parse_args(sys.argv)[0]
outfile = open(options.outfile, "w")
pool = Pool()
needy_nodes = pool.where(
"isa_partition and state not in ('refined','mdrun-failed')")
for n in needy_nodes:
outfile.write("%s, state: '%s':\n" % (n.name, n.state))
outfile.write(str(n.internals.array) + "\n")
outfile.write(
"mean pot.: %f, std pot.: %f, free energy estimate: %f\n" %
(n.obs.mean_V, n.obs.std_V, n.obs.A))
outfile.write(
"#========================================================================#\n"
)
outfile.close()
print "Pool info was written to %s." % options.outfile
def main():
options = options_desc.parse_args(sys.argv)[0]
pool = Pool()
needy_nodes = pool.where("state == 'grompp-able'")
assert(len(needy_nodes) == len(needy_nodes.multilock())) # make sure we lock ALL nodes
if(options.solv_model == "tip3p"):
solv_box = "spc216.gro"
solv_fn = "tip3p.itp"
elif(options.solv_model == "tip4p"):
solv_box = "tip4p.gro"
solv_fn = "tip4p.itp"
elif(options.solv_model == "tip4pew"):
solv_box = "tip4p.gro"
solv_fn = "tip4pew.itp"
elif(options.solv_model == "tip5"):
solv_box = "tip5p.gro"
solv_fn = "tip5p.itp"
elif(options.solv_model == "spc"):
solv_box = "spc216.gro"
solv_fn = "spc.itp"
elif(options.solv_model == "spce"):
solv_box = "spc216.gro"
solv_fn = "spce.itp"
# determine maximum length of linears, if any
max_linear = query_linear_length(pool)
# make box and fill with solvent
genbox(pool, max_linear, options.bt, (options.box_x, options.box_y, options.box_z), solv_box)
# update topology files (add solvent model and ions includes)
update_tops(pool, solv_fn)
for n in needy_nodes:
n.state = "em-grompp-able"
n.save()
n.unlock()
def is_applicable():
pool = Pool()
return(len(pool.where("state == 'grompp-able'")) > 0 or len(pool.where("state == 'em-grompp-able'")) > 0)
def is_applicable():
pool = Pool()
return (len(pool.where("isa_partition and is_sampled")) > 0)
def main():
options = options_desc.parse_args(sys.argv)[0]
pool = Pool()
active_nodes = pool.where("isa_partition")
if options.transition_level == "clusters":
npz_file = np.load(pool.chi_mat_fn)
chi_matrix = npz_file['matrix']
n_clusters = npz_file['n_clusters']
default_cluster_threshold = options.coreset_power
# determine cluster
#TODO this part is too cryptic
# amount_phi[j] = amount of basis functions per cluster j
amount_phi=np.ones(n_clusters,dtype=np.uint64)
amount_phi=amount_phi*len(chi_matrix)
amount_phi_total=len(chi_matrix)
# sort columns of chi and return new sorted args
arg_sort_cluster=np.argsort(chi_matrix,axis=0)
# sort columns of chi and return new sorted chi
# notice that the last row has to be [1 ... 1]
sort_cluster=np.sort(chi_matrix,axis=0)
# show_cluster contains arrays of the type [a b] where a is the row
# and b the column of the entry from chi matrix where
# chi_sorted(a,b) > default_cluster_threshold
show_cluster=np.argwhere(sort_cluster > 0.5 )
# from the above it could be clear
# that the amount of phi function
# of cluster i is given by x where x the number so that
# [x i] is in show_cluster and for all
# [y i] in show_cluster we have x>y
# we define amount_phi[i]=x
for element in show_cluster:
index=element[0]
cluster=element[1]
if amount_phi[cluster]>index:
amount_phi[cluster]=index
# create cluster list which contains arrays
# each array consinst of a set of numbers corresponding to
# the phi function of node_number
cluster=[]
for i in range(0,n_clusters):
cluster_set=[]
for j in range(amount_phi[i],amount_phi_total):
#if (j < amount_phi[i] + 3):
cluster_set.append(arg_sort_cluster[j][i])
cluster.append(cluster_set)
for i in range(len(cluster)):
counter = 0
for node_index in cluster[i]:
counter += 1
# and ignore nodes which have a higher chi value then default_cluster_threshold
if( chi_matrix[node_index][i] > default_cluster_threshold and counter>options.min_nodes):
continue
node = active_nodes[node_index]
trajectory= node.trajectory
print "-----"
print "Generating transition nodes for node %s..."%node.name
neighbour_frames = get_indices_equidist(node, options.num_tnodes)
# create transition node for node_index
for frame_number in neighbour_frames:
print "Using frame %d as starting configuration."%frame_number
n = Node()
n.parent_frame_num = frame_number
n.parent = node
n.state = "created"
n.extensions_counter = 0
n.extensions_max = options.num_runs-1
n.extensions_length = options.sampling_length
n.sampling_length = options.sampling_length
n.internals = trajectory.getframe(frame_number)
n.save_mode = options.save_mode
pool.append(n)
n.save()
print "%d transition nodes generated."%options.num_tnodes
print "-----"
zgf_setup_nodes.main()
zgf_grompp.main()
cluster_dict = {}
for (ic,c) in enumerate(cluster):
cluster_dict['cluster_%d'%ic] = c
# save cluster
np.savez(pool.analysis_dir+"core_set_cluster.npz", **cluster_dict)
elif options.transition_level == "nodes":
for node in active_nodes:
trajectory= node.trajectory
# TODO duplicate code... use the one above
print "-----"
print "Generating transition nodes for node %s..."%node.name
neighbour_frames = get_indices_equidist(node, options.num_tnodes)
# create transition point for node_index
for frame_number in neighbour_frames:
print "Using frame %d as starting configuration."%frame_number
n = Node()
n.parent_frame_num = frame_number
n.parent = node
n.state = "created"
n.extensions_counter = 0
n.extensions_max = options.num_runs-1
n.extensions_length = options.sampling_length
n.sampling_length = options.sampling_length
n.internals = trajectory.getframe(frame_number)
n.save_mode = options.save_mode
pool.append(n)
n.save()
print "%d transition nodes generated."%options.num_tnodes
print "-----"
zgf_setup_nodes.main()
zgf_grompp.main()
instructionFile = pool.analysis_dir+"instruction.txt"
f = open(instructionFile, "w")
f.write("{'power': %f, 'tnodes': %d, 'level': '%s', 'min_nodes': %d}"%(options.coreset_power, options.num_tnodes, options.transition_level, options.min_nodes))
f.close()
def is_applicable():
pool = Pool()
return (pool.where("isa_partition and state != 'mdrun-failed'") > 0)
def main():
options = options_desc.parse_args(sys.argv)[0]
zgf_cleanup.main()
print("Options:\n%s\n"%pformat(eval(str(options))))
pool = Pool()
parent = pool.root
active_nodes = pool.where("isa_partition")
assert(len(active_nodes) == len(active_nodes.multilock())) # make sure we lock ALL nodes
if active_nodes.where("'weight_direct' not in obs"):
sys.exit("Q-Matrix calculation not possible: Not all of the nodes have been reweighted.")
node_weights = np.array([node.obs.weight_direct for node in active_nodes])
print "### Generate bins: equidist ###"
result = q_equidist(parent, options.numnodes)
chosen_idx=result['chosen_idx']
frames_chosen=result['frames_chosen']
theta=result['theta']
chosen_idx.sort() # makes preview-trajectory easier to understand
dimension=len(chosen_idx)
print "chosen_idx"
print chosen_idx
print "### Generate bin weights ###"
bin_weights=np.zeros(dimension)
for (i,n) in enumerate(active_nodes):
w_denom = np.sum(n.frameweights)
for t in range(len(n.trajectory)):
diffs = (frames_chosen - n.trajectory.getframe(t)).norm()
j = np.argmin(diffs)
bin_weights[j] = bin_weights[j] + node_weights[i] * n.frameweights[t] / w_denom
print "bin_weights"
print bin_weights
print "### Generate q_all (entries only for neighboring bins) ###"
q_all = np.empty((dimension, dimension), dtype=np.float)
for i in range(dimension):
sum_row = 0.0
diffs = (frames_chosen - frames_chosen.getframe(i)).norm()
print "diffs"
print diffs
for j in range(dimension):
if (diffs[j] < 2.0 * theta) and (bin_weights[i] > 0.0):
q_all[i,j] = np.sqrt(bin_weights[j]) / np.sqrt(bin_weights[i])
sum_row = sum_row + q_all[i , j]
else:
q_all[i,j] = 0
q_all[i, i] = q_all[i, i]- sum_row
print "Q_All"
print q_all
if options.export_matlab:
savemat(pool.analysis_dir+"q_all.mat", {"q_all":q_all})
active_nodes.unlock()
zgf_cleanup.main()
def is_applicable():
pool = Pool()
return(len(pool.where("state=='mdrun-able'")) > 0)
def is_applicable():
pool = Pool()
return( len(pool.where("'weight_direct' in obs")) > 0 and len(pool.where("isa_partition and 'weight_direct' not in obs")) == 0 )
def is_applicable():
pool = Pool()
return(len(pool.where("state in ('em-mdrun-able', 'mdrun-able', 'converged', 'not-converged', 'rerun-able-converged', 'rerun-able-not-converged')")) > 0)
def is_applicable():
pool = Pool()
return (len(pool) > 1 and len(
pool.where(
"isa_partition and state in ('converged','not-converged','mdrun-failed')"
)) == len(pool.where("isa_partition")))
def is_applicable():
pool = Pool()
return (len(pool.where("state == 'em-mdrun-able'")) > 0)
def is_applicable():
pool = Pool()
return( len(pool.where("'weight_direct' in obs")) > 0 and len(pool.where("isa_partition and 'weight_direct' not in obs")) == 0 )
def is_applicable():
pool = Pool()
return (len(pool.where("state == 'grompp-able'")) > 0)
def is_applicable():
pool = Pool()
return(len(pool.where("state == 'created'")) > 0)
def is_applicable():
pool = Pool()
return( len(pool.where("state in ('converged', 'not-converged', 'refined')")) > 1 )
def main():
options = options_desc.parse_args(sys.argv)[0]
zgf_cleanup.main()
pool = Pool()
active_nodes = pool.where("isa_partition")
if(options.ignore_failed):
active_nodes = pool.where("isa_partition and not state=='mdrun-failed'")
assert(len(active_nodes) == len(active_nodes.multilock())) # make sure we lock ALL nodes
if active_nodes.where("'weight_direct' not in obs"):
active_nodes.unlock()
sys.exit("Matrix calculation not possible: Not all of the nodes have been reweighted.")
print "\n### Getting S matrix ..."
s_matrix = cache_matrix(pool.s_mat_fn, active_nodes, overwrite=options.overwrite_mat, fast=options.fast_mat)
register_file_dependency(pool.s_mat_fn, pool.filename)
node_weights = np.array([node.obs.weight_direct for node in active_nodes])
print "\n### Symmetrizing S matrix ..."
(corr_s_matrix, corr_node_weights) = symmetrize(s_matrix, node_weights, correct_weights=True, error=float(options.error))
# store intermediate results
register_file_dependency(pool.s_corr_mat_fn, pool.s_mat_fn)
np.savez(pool.s_corr_mat_fn, matrix=corr_s_matrix, node_names=[n.name for n in active_nodes])
if options.export_matlab:
savemat(pool.analysis_dir+"node_weights.mat", {"node_weights":node_weights, "node_weights_corrected":corr_node_weights})
savemat(pool.analysis_dir+"s_mats.mat", {"s_matrix":s_matrix, "s_matrix_corrected":corr_s_matrix})
for (n, cw) in zip(active_nodes, corr_node_weights):
n.obs.weight_corrected = cw
print "\n### Node weights after symmetrization of S matrix:"
for n in active_nodes:
print "%s: initial weight: %f, corrected weight: %f, weight change: %f" % (n.name, n.obs.weight_direct, n.obs.weight_corrected, abs(n.obs.weight_direct - n.obs.weight_corrected))
n.save()
active_nodes.unlock()
# calculate and sort eigenvalues in descending order
(eigvalues, eigvectors) = np.linalg.eig(corr_s_matrix)
argsorted_eigvalues = np.argsort(-eigvalues)
eigvalues = eigvalues[argsorted_eigvalues]
eigvectors = eigvectors[:, argsorted_eigvalues]
gaps = np.abs(eigvalues[1:]-eigvalues[:-1])
gaps = np.append(gaps, 0.0)
wgaps = gaps*eigvalues
print "\n### Sorted eigenvalues of symmetrized S matrix:"
for (idx, ev, gap, wgap) in zip(range(1, len(eigvalues)+1), eigvalues, gaps, wgaps):
print "EV%04d: %f, gap to next: %f, EV-weighted gap to next: %f" % (idx, ev, gap, wgap)
n_clusters = np.argmax(wgaps)+1
print "\n### Maximum gap %f after top %d eigenvalues." % (np.max(gaps), n_clusters)
print "### Maximum EV-weighted gap %f after top %d eigenvalues." % (np.max(wgaps), np.argmax(wgaps)+1)
sys.stdout.flush()
if not options.auto_cluster:
n_clusters = userinput("Please enter the number of clusters for PCCA+", "int", "x>0")
print "### Using %d clusters for PCCA+ ..."%n_clusters
if options.export_matlab:
savemat(pool.analysis_dir+"evs.mat", {"evs":eigvectors})
# orthogonalize and normalize eigenvectors
eigvectors = orthogonalize(eigvalues, eigvectors, corr_node_weights)
# perform PCCA+
# First two return-values "c_f" and "indicator" are not needed
(chi_matrix, rot_matrix) = cluster_by_isa(eigvectors, n_clusters)[2:]
if(options.optimize_chi):
print "\n### Optimizing chi matrix ..."
outliers = 5
mean_weight = np.mean(corr_node_weights)
threshold = mean_weight/100*outliers
print "Light-weight node threshold (%d%% of mean corrected node weight): %.4f."%(outliers, threshold)
# accumulate nodes for optimization
edges = np.where(np.max(chi_matrix, axis=1) > 0.9999)[0] # edges of simplex
heavies = np.where( corr_node_weights > threshold)[0] # heavy-weight nodes
filtered_eigvectors = eigvectors[ np.union1d(edges, heavies) ]
# perform the actual optimization
rot_matrix = opt_soft(filtered_eigvectors, rot_matrix, n_clusters)
chi_matrix = np.dot(eigvectors[:,:n_clusters], rot_matrix)
# deal with light-weight nodes: shift and scale
for i in np.where(corr_node_weights <= threshold)[0]:
if(i in edges):
print "Column %d belongs to (potentially dangerous) light-weight node, but its node is a simplex edge."%(i+1)
continue
print "Column %d is shifted and scaled."%(i+1)
col_min = np.min( chi_matrix[i,:] )
chi_matrix[i,:] -= col_min
chi_matrix[i,:] /= 1-(n_clusters*col_min)
qc_matrix = np.dot( np.dot( np.linalg.inv(rot_matrix), np.diag(eigvalues[range(n_clusters)]) ), rot_matrix ) - np.eye(n_clusters)
cluster_weights = rot_matrix[0]
print "\n### Matrix numerics check"
print "-- Q_c matrix row sums --"
print np.sum(qc_matrix, axis=1)
print "-- cluster weights: first column of rot_matrix --"
print cluster_weights
print "-- cluster weights: numpy.dot(node_weights, chi_matrix) --"
print np.dot(corr_node_weights, chi_matrix)
print "-- chi matrix column max values --"
print np.max(chi_matrix, axis=0)
print "-- chi matrix row sums --"
print np.sum(chi_matrix, axis=1)
# store final results
np.savez(pool.chi_mat_fn, matrix=chi_matrix, n_clusters=n_clusters, node_names=[n.name for n in active_nodes])
np.savez(pool.qc_mat_fn, matrix=qc_matrix, n_clusters=n_clusters, node_names=[n.name for n in active_nodes], weights=cluster_weights)
if options.export_matlab:
savemat(pool.analysis_dir+"chi_mat.mat", {"chi_matrix":chi_matrix})
savemat(pool.analysis_dir+"qc_mat.mat", {"qc_matrix":qc_matrix, "weights":cluster_weights})
register_file_dependency(pool.chi_mat_fn, pool.s_corr_mat_fn)
register_file_dependency(pool.qc_mat_fn, pool.s_corr_mat_fn)
for fn in (pool.s_mat_fn, pool.s_corr_mat_fn):
register_file_dependency(pool.chi_mat_fn, fn)
register_file_dependency(pool.qc_mat_fn, fn)
# touch analysis directory (triggering update in zgf_browser)
atime = mtime = time.time()
os.utime(pool.analysis_dir, (atime, mtime))
# show summary
if(options.summary):
print "\n### Preparing cluster summary ..."
chi_threshold = 1E-3
from pprint import pformat
for i in range(n_clusters):
involved_nodes = [active_nodes[ni] for ni in np.argwhere(chi_matrix[:,i] > chi_threshold)]
max_chi_node = active_nodes[ np.argmax(chi_matrix[:,i]) ]
c_max = []
for c in pool.converter:
coord_range = pool.coord_range(c)
scale = c.plot_scale
edges = scale(np.linspace(np.min(coord_range), np.max(coord_range), num=50))
hist_cluster = np.zeros(edges.size-1)
for (n, chi) in zip([n for n in active_nodes], chi_matrix[:,i]):
samples = scale( n.trajectory.getcoord(c) )
hist_node = np.histogram(samples, bins=edges, weights=n.frameweights, normed=True)[0]
hist_cluster += n.obs.weight_corrected * hist_node * chi
c_max.append( scale(np.linspace(np.min(coord_range), np.max(coord_range), num=50))[np.argmax(hist_cluster)] )
msg = "### Cluster %d (weight=%.4f, #involved nodes=%d, representative='%s'):"%(i+1, cluster_weights[i], len(involved_nodes), max_chi_node.name)
print "\n"+msg
print "-- internal coordinates --"
print "%s"%pformat(["%.2f"%cm for cm in c_max])
print "-- involved nodes --"
print "%s"%pformat([n.name for n in involved_nodes])
print "-"*len(msg)
def main():
options = options_desc.parse_args(sys.argv)[0]
pool = Pool()
active_nodes = pool.where("isa_partition")
# check if zgf_create_tnodes was executed before
assert (os.path.exists(pool.analysis_dir + "instruction.txt"))
try:
f = open(pool.analysis_dir + "instruction.txt")
command = f.read()
instructions = eval(command)
except:
raise (Exception("Could not parse: " + pool.analysis_dir +
"instruction.txt"))
transition_level = instructions['level']
n_tnodes = instructions['tnodes']
all_ready_nodes = pool.where("state == 'ready'")
n_runs = all_ready_nodes[0].extensions_max + 1
assert (all_ready_nodes[0].sampling_length ==
all_ready_nodes[0].extensions_length)
tau = all_ready_nodes[0].sampling_length
# let's calculate a Pc matrix
if transition_level == "clusters":
default_cluster_threshold = instructions['power']
min_nodes = instructions['min_nodes']
npz_file = np.load(pool.chi_mat_fn)
chi_matrix = npz_file['matrix']
npz_file = np.load(pool.analysis_dir + "core_set_cluster.npz")
cluster = [npz_file[c] for c in sorted(npz_file.files)]
Pc = np.zeros(shape=(len(cluster), len(cluster)))
print "For each node, sample %d tnodes with %d runs" % (n_tnodes,
n_runs)
# start calculating matrix
cluster_index_i = 0 #TODO maker nicer
for i in range(len(cluster)):
print "\n CLUSTER %d contains the following nodes:" % i
print cluster[i]
counter = 0
for node_index in cluster[i]:
counter = counter + 1
node = active_nodes[node_index]
frameweights_of_node_i = node.frameweights
# and nodes which have a higher chi value then default_cluster_threshold
if (chi_matrix[node_index][i] > default_cluster_threshold
and counter > min_nodes):
print "Node " + str(
node_index
) #TODO this index is not the global node index... somewhat misleading
print "chi value: " + str(chi_matrix[node_index][i])
print "counter: " + str(counter)
print "cluster: " + str(cluster_index_i)
print "no tnodes"
print "- - - -"
# for other nodes add corresponding Pc value - assuming those cluster are metastable
trajectory = node.trajectory
tnode_frames = get_indices_equidist(node, n_tnodes)
for frame_number in tnode_frames:
# behave like node would not move in simulation
weight = frameweights_of_node_i[frame_number]
#TODO: add option for calculat Matrix without soft chi_matrix
Pc[cluster_index_i,
cluster_index_i] += n_runs * weight * node.obs.weight_corrected * chi_matrix[
node_index][cluster_index_i] * chi_matrix[
node_index][cluster_index_i]
continue
ready_nodes = pool.where(
"state == 'ready' and parent!=None and parent.name=='%s'" %
node.name)
print "Node " + str(
node_index
) #TODO this index is not the global node index... somewhat misleading
print "chi value: " + str(chi_matrix[node_index][i])
print "counter: " + str(counter)
print "cluster: " + str(cluster_index_i)
print "#tnodes: " + str(len(ready_nodes))
print "- - - -"
for ready_node in ready_nodes:
weight = frameweights_of_node_i[
ready_node.parent_frame_num]
#frame_value = pool.converter.read_pdb(ready_node.pdb_fn)
#temp_dist=(frame_value - node_i.internals).norm2()
#iterate pdb files
for fn in os.listdir(ready_node.dir):
if (re.match(".+.pdb", fn)):
# add radius feature in future
frame_value = pool.converter.read_pdb(
ready_node.dir + "/" + fn)
#calculate distances
temp_val = np.zeros(len(active_nodes))
index_temp = 0
for node_temp in active_nodes:
temp_val[index_temp] = (
frame_value - node_temp.internals).norm2()
index_temp = index_temp + 1
# which node has closest distance?
index_j = np.argsort(temp_val)[0]
#which cluster has highest chi value?
cluster_index_j = np.argsort(
chi_matrix[index_j][:])[len(cluster) - 1]
#calc Pc entry
Pc[cluster_index_i,
cluster_index_j] += weight * node.obs.weight_corrected * chi_matrix[
node_index][cluster_index_i] * chi_matrix[
index_j][cluster_index_j]
cluster_index_i = cluster_index_i + 1
for i in range(0, len(cluster)):
factor = sum(Pc[i, :])
Pc[i, :] = (1 / factor) * Pc[i, :]
# store final results
np.savez(pool.pc_mat_fn,
matrix=Pc,
node_names=[n.name for n in active_nodes
]) #TODO store additional info?
if options.export_matlab:
savemat(pool.analysis_dir + "pc_mat.mat", {"Pc_matrix": Pc})
# let's calculate a P matrix
elif transition_level == "nodes":
P = np.zeros(shape=(len(active_nodes), len(active_nodes)))
P_hard = np.zeros(shape=(len(active_nodes), len(active_nodes)))
index_i = 0
for node_i in active_nodes:
# get frameweights and ready_nodes
ready_nodes = pool.where(
"state == 'ready' and parent!=None and parent.name=='%s'" %
node_i.name)
frameweights_of_node_i = node_i.frameweights
for ready_node in ready_nodes:
weight = frameweights_of_node_i[ready_node.parent_frame_num]
frame_value = pool.converter.read_pdb(ready_node.pdb_fn)
temp_dist = (frame_value - node_i.internals).norm2()
legal_ready_node = True
for node_temp in active_nodes:
if (temp_dist >
(frame_value - node_temp.internals).norm2()):
legal_ready_node = False
print "strange ready node!"
#iterate pdb files
#if(temp_dist <= p_radius):
if (legal_ready_node):
for fn in os.listdir(ready_node.dir):
if (re.match("[^#].+.pdb", fn)):
# add radius feature in future
#print "Filedirectory"
#print ready_node.dir+"/"+fn
frame_value = pool.converter.read_pdb(
ready_node.dir + "/" + fn)
#calculate distances
temp_val = np.zeros(len(active_nodes))
index_temp = 0
for node_temp in active_nodes:
temp_val[index_temp] = (
frame_value - node_temp.internals).norm2()
index_temp = index_temp + 1
index_j = np.argsort(temp_val)[0]
#calc P entry
#if(temp_val[index_j] <= p_radius):
P[index_i,
index_j] += weight * node_i.obs.weight_corrected
P_hard[index_i, index_j] += 1
index_i = index_i + 1
for i in range(0, len(active_nodes)):
factor = sum(P[i, :])
P[i, :] = (1 / factor) * P[i, :]
# store final results
np.savez(pool.p_mat_fn,
matrix=P,
node_names=[n.name for n in active_nodes
]) #TODO store additional info?
if options.export_matlab:
savemat(pool.analysis_dir + "p_mat.mat", {"P_matrix": P})
if transition_level == "clusters":
print "Clusters: " + str(cluster)
print "Transition matrix Pc for tau = %d ps:" % tau
print Pc
elif transition_level == "nodes":
print "Nodes: " + str(active_nodes)
print "Transition matrix P for tau = %d ps:" % tau
print P
def is_applicable():
pool = Pool()
return(len(pool.where("isa_partition and is_sampled")) > 0)
def main():
options = options_desc.parse_args(sys.argv)[0]
pool = Pool()
needy_nodes = pool.where("state == 'merge-able'").multilock()
if (len(needy_nodes) == 0):
return
# find out about trr time step
dt = 0
nodeDir = needy_nodes[0].dir.split('/')[-1]
for fn in os.listdir(needy_nodes[0].dir):
if re.match("^" + nodeDir + ".+run\d+\.trr", fn):
trr = TrrFile(needy_nodes[0].dir + "/" + fn)
dt = trr.first_frame.next().t - trr.first_frame.t
trr.close()
break
# dt is sometimes noisy in the final digits (three digits is femtosecond step = enough)
dt = np.around(dt, decimals=3)
for n in needy_nodes:
if (options.trr):
# merge sampling trajectories
trr_fns = sorted([
fn for fn in os.listdir(n.dir)
if re.match("[^#].+run\d+.trr", fn)
])
cmd = ["trjcat", "-f"]
cmd += trr_fns
cmd += ["-o", "../../" + n.trr_fn, "-cat"]
print("Calling: %s" % " ".join(cmd))
check_call(cmd, cwd=n.dir)
if (options.edr):
# merge edr files
# get list of edr-files
edr_fnames = sorted([
n.dir + "/" + fn for fn in os.listdir(n.dir)
if re.match("[^#].+run\d+.edr", fn)
])
assert (len(edr_fnames) == n.extensions_counter + 1)
assert (len(edr_fnames) == n.extensions_max + 1)
time_offset = n.sampling_length + dt
for edr_fn in edr_fnames[1:]:
# adapt edr starting times
cmd = ["eneconv", "-f", edr_fn, "-o", edr_fn, "-settime"]
print("Calling: " + (" ".join(cmd)))
p = Popen(cmd, stdin=PIPE)
p.communicate(input=(str(time_offset) + "\n"))
assert (p.wait() == 0)
time_offset += n.extensions_length + dt
# concatenate edr files with adapted starting times
cmd = ["eneconv", "-f"] + edr_fnames + ["-o", n.dir + "/ener.edr"]
print("Calling: " + (" ".join(cmd)))
p = Popen(cmd)
retcode = p.wait()
assert (retcode == 0)
needy_nodes.unlock()
def main():
pool = Pool()
for n in pool.where("isa_partition"):
for cn in n.children.where("is_sampled"):
print cn.trajectory
def main():
pool = Pool()
for n in pool.where("isa_partition"):
for cn in n.children.where("is_sampled"):
print cn.trajectory
def is_applicable():
pool = Pool()
return( len(pool) > 1 and len(pool.where("isa_partition and state in ('converged','not-converged','mdrun-failed')")) == len(pool.where("isa_partition")) )
def main():
options = options_desc.parse_args(sys.argv)[0]
zgf_cleanup.main()
print("Options:\n%s\n"%pformat(eval(str(options))))
pool = Pool()
parent = pool.root
active_nodes = pool.where("isa_partition")
assert(len(active_nodes) == len(active_nodes.multilock())) # make sure we lock ALL nodes
if active_nodes.where("'weight_direct' not in obs"):
sys.exit("Q-Matrix calculation not possible: Not all of the nodes have been reweighted.")
node_weights = np.array([node.obs.weight_direct for node in active_nodes])
print "### Generate bins: equidist ###"
result = q_equidist(parent, options.numnodes)
chosen_idx=result['chosen_idx']
frames_chosen=result['frames_chosen']
theta=result['theta']
chosen_idx.sort() # makes preview-trajectory easier to understand
dimension=len(chosen_idx)
print "chosen_idx"
print chosen_idx
print "### Generate bin weights ###"
bin_weights=np.zeros(dimension)
for (i,n) in enumerate(active_nodes):
w_denom = np.sum(n.frameweights)
for t in range(len(n.trajectory)):
diffs = (frames_chosen - n.trajectory.getframe(t)).norm()
j = np.argmin(diffs)
bin_weights[j] = bin_weights[j] + node_weights[i] * n.frameweights[t] / w_denom
print "bin_weights"
print bin_weights
print "### Generate q_all (entries only for neighboring bins) ###"
q_all = np.empty((dimension, dimension), dtype=np.float)
for i in range(dimension):
sum_row = 0.0
diffs = (frames_chosen - frames_chosen.getframe(i)).norm()
print "diffs"
print diffs
for j in range(dimension):
if (diffs[j] < 2.0 * theta) and (bin_weights[i] > 0.0):
q_all[i,j] = np.sqrt(bin_weights[j]) / np.sqrt(bin_weights[i])
sum_row = sum_row + q_all[i , j]
else:
q_all[i,j] = 0
q_all[i, i] = q_all[i, i]- sum_row
print "Q_All"
print q_all
if options.export_matlab:
savemat(pool.analysis_dir+"q_all.mat", {"q_all":q_all})
active_nodes.unlock()
zgf_cleanup.main()
def main():
options = options_desc.parse_args(sys.argv)[0]
pool = Pool()
if options.ignore_convergence:
needy_nodes = pool.where("state in ('converged','not-converged')")
else:
needy_nodes = pool.where("state == 'converged'")
assert(len(needy_nodes) == len(needy_nodes.multilock())) # make sure we lock ALL nodes
for node in needy_nodes:
if ( path.exists(node.dir+"/rerun_me.trr") and path.exists(node.dir+"/rerun_me.pdb") and path.exists(node.dir+"/rerun_me.top") and path.exists(node.dir+"/rerun_me.tpr") ):
print("All four rerun files (rerun_me.*) already existing in " + node.dir + ".")
print("Be sure you want to keep them!")
continue
# if "none", assume that sim is implicit or in vacuum. thus, trjconv not required.
if options.pbc_removal != "none":
# desolvate trr
if not( path.exists(node.dir+"/rerun_me.trr")):
cmd = ["trjconv", "-f", node.trr_fn, "-o", node.dir+"/rerun_me.trr", "-s", node.tpr_fn, "-n", node.pool.ndx_fn, "-pbc", options.pbc_removal]
print("Calling: "+(" ".join(cmd)))
p = Popen(cmd, stdin=PIPE)
p.communicate(input=("MOI\n"))
assert(p.wait() == 0)
else:
print("Rerun trajectory file (rerun_me.trr) already existing in " + node.dir + ".")
print("Be sure you want to keep it!")
#sys.exit(0)
#continue
# desolvate pdb
if not( path.exists(node.dir+"/rerun_me.pdb") ):
cmd = ["trjconv", "-f", node.pdb_fn, "-o", node.dir+"/rerun_me.pdb", "-s", node.tpr_fn, "-n", node.pool.ndx_fn, "-pbc", options.pbc_removal]
print("Calling: "+(" ".join(cmd)))
p = Popen(cmd, stdin=PIPE)
p.communicate(input=("MOI\n"))
assert(p.wait() == 0)
# desolvate topology
infile = open(node.top_fn, "r").readlines()
mol_section = False
out_top = []
for line in infile:
if( re.match("\s*\[\s*(molecules)\s*\]\s*", line.lower()) ):
# we are past the "molecules" section
mol_section = True
if(mol_section):
# comment out lines that belong to solvent (SOL, CL, NA)... add more if necessary
if( re.match("\s*(sol|cl|na|tsl|tcm|mth)\s*\d+", line.lower()) ):
line = ";"+line
out_top.append(line)
outfile = open(node.dir+"/rerun_me.top","w").writelines(out_top)
else:
if not( path.exists(node.dir+"/rerun_me.trr") ):
symlink(node.name+".trr", node.dir+"/rerun_me.trr")
else:
print("Rerun trajectory file (rerun_me.trr) already existing in " + node.dir + ".")
print("Be sure you want to keep it!")
#continue
if not( path.exists(node.dir+"/rerun_me.pdb") ):
symlink(node.name+"_conf.pdb", node.dir+"/rerun_me.pdb")
if not( path.exists(node.dir+"/rerun_me.top") ):
symlink(node.name+".top", node.dir+"/rerun_me.top")
grompp2state = "rerun-able-"+node.state
# get rid of old checkpoint file (it might mess up the rerun)
if( path.exists(node.dir+"/state.cpt") ):
remove(node.dir+"/state.cpt")
#zgf_grompp.call_grompp(node, mdp_file=options.grompp, final_state=grompp2state)
#TODO code borrowed from zgf_grompp
#TODO make the original method fit for grompping reruns
if not( path.exists(node.dir+"/rerun_me.trr") ):
cmd = ["grompp"]
cmd += ["-f", "../../"+options.grompp]
cmd += ["-n", "../../"+node.pool.ndx_fn]
cmd += ["-c", "../../"+node.dir+"/rerun_me.pdb"]
cmd += ["-p", "../../"+node.dir+"/rerun_me.top"]
cmd += ["-o", "../../"+node.dir+"/rerun_me.tpr"]
print("Calling: %s"%" ".join(cmd))
p = Popen(cmd, cwd=node.dir)
retcode = p.wait()
assert(retcode == 0) # grompp should never fail
node.state = grompp2state
node.save()
node.unlock()
def main():
options = options_desc.parse_args(sys.argv)[0]
pool = Pool()
if options.ignore_convergence:
needy_nodes = pool.where("state in ('converged','not-converged')")
else:
needy_nodes = pool.where("state == 'converged'")
assert (len(needy_nodes) == len(needy_nodes.multilock())
) # make sure we lock ALL nodes
for node in needy_nodes:
if (path.exists(node.dir + "/rerun_me.trr")
and path.exists(node.dir + "/rerun_me.pdb")
and path.exists(node.dir + "/rerun_me.top")
and path.exists(node.dir + "/rerun_me.tpr")):
print("All four rerun files (rerun_me.*) already existing in " +
node.dir + ".")
print("Be sure you want to keep them!")
continue
# if "none", assume that sim is implicit or in vacuum. thus, trjconv not required.
if options.pbc_removal != "none":
# desolvate trr
if not (path.exists(node.dir + "/rerun_me.trr")):
cmd = [
"trjconv", "-f", node.trr_fn, "-o",
node.dir + "/rerun_me.trr", "-s", node.tpr_fn, "-n",
node.pool.ndx_fn, "-pbc", options.pbc_removal
]
print("Calling: " + (" ".join(cmd)))
p = Popen(cmd, stdin=PIPE)
p.communicate(input=("MOI\n"))
assert (p.wait() == 0)
else:
print(
"Rerun trajectory file (rerun_me.trr) already existing in "
+ node.dir + ".")
print("Be sure you want to keep it!")
#sys.exit(0)
#continue
# desolvate pdb
if not (path.exists(node.dir + "/rerun_me.pdb")):
cmd = [
"trjconv", "-f", node.pdb_fn, "-o",
node.dir + "/rerun_me.pdb", "-s", node.tpr_fn, "-n",
node.pool.ndx_fn, "-pbc", options.pbc_removal
]
print("Calling: " + (" ".join(cmd)))
p = Popen(cmd, stdin=PIPE)
p.communicate(input=("MOI\n"))
assert (p.wait() == 0)
# desolvate topology
infile = open(node.top_fn, "r").readlines()
mol_section = False
out_top = []
for line in infile:
if (re.match("\s*\[\s*(molecules)\s*\]\s*", line.lower())):
# we are past the "molecules" section
mol_section = True
if (mol_section):
# comment out lines that belong to solvent (SOL, CL, NA)... add more if necessary
if (re.match("\s*(sol|cl|na|tsl|tcm|mth)\s*\d+",
line.lower())):
line = ";" + line
out_top.append(line)
outfile = open(node.dir + "/rerun_me.top", "w").writelines(out_top)
else:
if not (path.exists(node.dir + "/rerun_me.trr")):
symlink(node.name + ".trr", node.dir + "/rerun_me.trr")
else:
print(
"Rerun trajectory file (rerun_me.trr) already existing in "
+ node.dir + ".")
print("Be sure you want to keep it!")
#continue
if not (path.exists(node.dir + "/rerun_me.pdb")):
symlink(node.name + "_conf.pdb", node.dir + "/rerun_me.pdb")
if not (path.exists(node.dir + "/rerun_me.top")):
symlink(node.name + ".top", node.dir + "/rerun_me.top")
grompp2state = "rerun-able-" + node.state
# get rid of old checkpoint file (it might mess up the rerun)
if (path.exists(node.dir + "/state.cpt")):
remove(node.dir + "/state.cpt")
#zgf_grompp.call_grompp(node, mdp_file=options.grompp, final_state=grompp2state)
#TODO code borrowed from zgf_grompp
#TODO make the original method fit for grompping reruns
if not (path.exists(node.dir + "/rerun_me.trr")):
cmd = ["grompp"]
cmd += ["-f", "../../" + options.grompp]
cmd += ["-n", "../../" + node.pool.ndx_fn]
cmd += ["-c", "../../" + node.dir + "/rerun_me.pdb"]
cmd += ["-p", "../../" + node.dir + "/rerun_me.top"]
cmd += ["-o", "../../" + node.dir + "/rerun_me.tpr"]
print("Calling: %s" % " ".join(cmd))
p = Popen(cmd, cwd=node.dir)
retcode = p.wait()
assert (retcode == 0) # grompp should never fail
node.state = grompp2state
node.save()
node.unlock()
def is_applicable():
pool = Pool()
return (len(pool.where("state == 'created'")) > 0)
def main(argv=None):
if(argv==None):
argv = sys.argv
options = options_desc.parse_args(argv)[0]
print("Options:\n%s\n"%pformat(eval(str(options))))
if(options.random_seed):
# using numpy-random because python-random differs beetween 32 and 64 bit
np.random.seed(hash(options.random_seed))
pool = Pool()
old_pool_size = len(pool)
print "pool", pool
if(options.parent_node == "root"):
parent = pool.root
else:
found = [n for n in pool if n.name == options.parent_node]
assert(len(found) == 1)
parent = found[0]
print "### Generate nodes: %s ###" % options.methodnodes
if(options.methodnodes == "kmeans"):
chosen_idx = mknodes_kmeans(parent, options.numnodes)
elif(options.methodnodes == "equidist"):
chosen_idx = mknodes_equidist(parent, options.numnodes)
elif(options.methodnodes == "maxdist"):
chosen_idx = mknodes_maxdist(parent, options.numnodes)
elif(options.methodnodes == "all"):
chosen_idx = mknodes_all(parent)
else:
raise(Exception("Method unknown: "+options.methodnodes))
chosen_idx.sort() # makes preview-trajectory easier to understand
if(options.write_preview):
write_node_preview(pool, parent, chosen_idx)
for i in chosen_idx:
n = Node()
n.parent_frame_num = i
n.parent = parent
n.state = "creating-a-partition" # will be set to "created" at end of script
n.extensions_counter = 0
n.extensions_max = options.ext_max
n.extensions_length = options.ext_length
n.sampling_length = options.sampling_length
n.internals = parent.trajectory.getframe(i)
pool.append(n)
print "\n### Obtain alpha: %s ###" % options.methodalphas
old_alpha = pool.alpha
if(options.methodalphas == "theta"):
pool.alpha = calc_alpha_theta(pool)
elif(options.methodalphas == "user"):
pool.alpha = userinput("Please enter a value for alpha", "float")
else:
raise(Exception("Method unknown: "+options.methodalphas))
pool.history.append({'refined_node': (parent.name, parent.state), 'size':old_pool_size, 'alpha':old_alpha, 'timestamp':datetime.now()})
pool.save() # alpha might have changed
print "\n### Obtain phi fit: %s ###" % options.methodphifit
if(options.methodphifit == "harmonic"):
do_phifit_harmonic(pool)
elif(options.methodphifit == "switch"):
do_phifit_switch(pool)
elif(options.methodphifit == "leastsq"):
do_phifit_leastsq(pool)
else:
raise(Exception("Method unkown: "+options.methodphifit))
for n in pool.where("state == 'creating-a-partition'"):
n.state = "created"
n.save()
print "saving " +str(n)
zgf_cleanup.main()
def is_applicable():
pool = Pool()
return (len(
pool.where("state in ('converged', 'not-converged', 'refined')")) > 1)
