def test_fr16():
"""FR16: Create simulation input from simulation output.
*gmx.make_input handles state from checkpoints*
(requires interaction with library development)
"""
initial_input = gmx.read_tpr(tpr_filename)
md = gmx.mdrun(initial_input)
stage2_input = gmx.make_input(topology=initial_input,
conformation=md.output,
parameters=stage2_params,
simulation_state=md.output)
md = gmx.mdrun(stage2_input)
md.run()
def test_fr16():
"""FR16: Create simulation input from simulation output.
*gmx.make_input handles state from checkpoints*
(requires interaction with library development)
"""
initial_input = gmx.read_tpr(tpr_filename)
md = gmx.mdrun(initial_input)
stage2_input = gmx.make_input(topology=initial_input,
conformation=md.output,
parameters=stage2_params,
simulation_state=md.output)
md = gmx.mdrun(stage2_input)
md.run()
def test_fr7(spc_water_box):
"""FR7: Python bindings for launching simulations.
gmx.mdrun uses bindings to C++ API to launch simulations.
"""
md = gmx.mdrun(spc_water_box)
md.run()
def test_run_trivial_ensemble(spc_water_box, caplog):
from mpi4py import MPI
current_rank = MPI.COMM_WORLD.Get_rank()
with caplog.at_level(logging.DEBUG):
caplog.handler.setFormatter(formatter)
with caplog.at_level(logging.WARNING, 'gmxapi'), \
caplog.at_level(logging.DEBUG, 'gmxapi.mdrun'), \
caplog.at_level(logging.DEBUG, 'gmxapi.modify_input'), \
caplog.at_level(logging.DEBUG, 'gmxapi.read_tpr'), \
caplog.at_level(logging.DEBUG, 'gmxapi.simulation'):
tpr_filename = spc_water_box
ensemble_width = 2
simulation_input = gmx.read_tpr([tpr_filename] * ensemble_width)
assert simulation_input.output.ensemble_width == ensemble_width
assert len(simulation_input.output._simulation_input.result()
) == ensemble_width
md = gmx.mdrun(simulation_input)
assert md.output.ensemble_width == ensemble_width
md.run()
output_directory = md.output._work_dir.result()
logging.info('output_directory result: {}'.format(
str(output_directory)))
assert len(output_directory) == 2
# Note that the 'cleandir' test fixture will clean up the output directory on
# other ranks, so only check the current rank. Generally, our behavior
# is undefined if the client removes the working directory while the job
# is in progress. We can consider adding some sort of synchronization at
# the end of the job if running in temporary directories becomes an
# important use case outside of testing.
assert output_directory[0] != output_directory[1]
assert os.path.exists(output_directory[current_rank])
assert os.path.exists(md.output.trajectory.result()[current_rank])
def single_run(self, name, log = False, template = "", additions = None):
# Preperes a run and runs it.
mdp_create(file_name = name + ".mdp",
new_parameters = self.mdp_settings[name],
old_file = template)
executable = "gmx"
arguments = ["grompp"]
input_files = {"-f": name + ".mdp",
"-c": self.configuration_file,
"-p": "topol.top"}
output_files = {"-o" : name + ".tpr"}
#print(name, "", executable, arguments, input_files, output_files,"","",sep="\n")
if additions:
if "in" in additions:
append_dict(input_files, additions["in"])
if "out" in additions:
append_dict(output_files, additions["out"])
#print(name, "", executable, arguments, input_files, output_files,"","",sep="\n")
prep = gmx.commandline_operation(executable = executable,
arguments = arguments,
input_files = input_files,
output_files = output_files)
prep.run()
print("prep "+ name + ":\n", prep.output.erroroutput.result())
mdrun = gmx.read_tpr(prep.output.file["-o"])
md = gmx.mdrun(mdrun)
md.run()
path = md.output.trajectory.result()
path = path[:path.rfind("/") + 1]
self.configuration_file = path + "confout.gro"
if log:
self.history.append(self.configuration_file)
self.latest_path = path
shutil.move(name + ".mdp", path + name + ".mdp")
def test_fr7():
"""FR7: Python bindings for launching simulations.
gmx.mdrun uses bindings to C++ API to launch simulations.
"""
md = gmx.mdrun(tprfilename)
md.run()
def test_fr12():
"""FR12: Simulation checkpoint handling
* gmx.mdrun is properly restartable
This should be invisible to the user, and requires introspection and testing infrastructure to properly test (TBD).
"""
from gmxapi import testsupport
simulation_input = gmx.read_tpr(initial_tpr)
md = gmx.mdrun(simulation_input, label='md')
interrupting_context = testsupport.interrupted_md(md)
with interrupting_context as session:
first_half_md = session.md.run()
md = gmx.mdrun(first_half_md, context=testsupport.inspect)
testsupport.verify_restart(md)
def test_fr15(spc_water_box, caplog):
"""FR15: Simulation input modification.
* *gmx.modify_input produces new (tpr) simulation input in data flow operation*
(requires interaction with library development)
"""
try:
from mpi4py import MPI
current_rank = MPI.COMM_WORLD.Get_rank()
ensemble_size = MPI.COMM_WORLD.Get_size()
except ImportError:
current_rank = 0
ensemble_size = 1
with caplog.at_level(logging.DEBUG):
caplog.handler.setFormatter(formatter)
with caplog.at_level(logging.WARNING, 'gmxapi'), \
caplog.at_level(logging.DEBUG, 'gmxapi.mdrun'), \
caplog.at_level(logging.DEBUG, 'gmxapi.modify_input'), \
caplog.at_level(logging.DEBUG, 'gmxapi.read_tpr'), \
caplog.at_level(logging.DEBUG, 'gmxapi.simulation'):
initial_input = gmx.read_tpr(
[spc_water_box for _ in range(ensemble_size)])
parameters = list([{'ld-seed': i} for i in range(ensemble_size)])
param_sweep = gmx.modify_input(input=initial_input,
parameters=parameters)
md = gmx.mdrun(param_sweep)
# TODO: (#3179) Handle ensembles of size 1 more elegantly.
if md.output.ensemble_width > 1:
result_list = md.output.parameters['ld-seed'].result()
else:
result_list = [md.output.parameters['ld-seed'].result()]
for expected, actual in zip(parameters, result_list):
assert expected['ld-seed'] == actual
def _(task: scalems.workflow.Task, context: WorkflowManager):
sublogger = logger.getChild('scalems_helper')
sublogger.debug('Serialized task record: {}'.format(task.serialize()))
command = task.type[-1]
assert command in {'Simulate', 'SimulationInput', 'Executable'}
# Right now, we should only need to process the 'Simulate' command...
assert command == 'Simulate'
# TODO: Typing on the Task data proxy.
command_message = task.input['message'][command]
# kwargs = command_message['kwargs']
input_ref: str = command_message['input']
logger.debug(f'Decoding reference {input_ref}')
input_ref: bytes = bytes.fromhex(input_ref)
task_map = context.task_map
logger.debug('Items done: {}'.format(
', '.join([': '.join([key.hex(), str(value.done())]) for key, value in task_map.items()])
))
# simulator_input_view = context.item(input_ref)
# TODO: Workaround until we have the framework deliver results.
# simulator_input: SubprocessResult = simulator_input_view.result()
# logger.debug(f'Acquired grompp output: {simulator_input}')
# tprfile = simulator_input.file['-o']
dependency_dir = pathlib.Path(os.getcwd()).parent / input_ref.hex()
tprfile = dependency_dir / 'topol.tpr'
import gmxapi
md_in = gmxapi.read_tpr(str(tprfile))
# TODO: Manage or integrate with gmxapi working directories.
md = gmxapi.mdrun(md_in)
# TODO: Make sure we mark interrupted simulations as "failed".
return md.run()
def test_run_trivial_ensemble(spc_water_box, caplog):
from mpi4py import MPI
current_rank = MPI.COMM_WORLD.Get_rank()
with caplog.at_level(logging.DEBUG):
caplog.handler.setFormatter(formatter)
with caplog.at_level(logging.WARNING, 'gmxapi'), \
caplog.at_level(logging.DEBUG, 'gmxapi.mdrun'), \
caplog.at_level(logging.DEBUG, 'gmxapi.modify_input'), \
caplog.at_level(logging.DEBUG, 'gmxapi.read_tpr'), \
caplog.at_level(logging.DEBUG, 'gmxapi.simulation'):
tpr_filename = spc_water_box
ensemble_width = 2
simulation_input = gmx.read_tpr([tpr_filename] * ensemble_width)
assert simulation_input.output.ensemble_width == ensemble_width
assert len(simulation_input.output._simulation_input.result()
) == ensemble_width
md = gmx.mdrun(simulation_input)
assert md.output.ensemble_width == ensemble_width
md.run()
output_directory = md.output._work_dir.result()
logging.info('output_directory result: {}'.format(
str(output_directory)))
assert len(output_directory) == 2
# Note that the 'cleandir' test fixture will clean up the output directory on
# other ranks, so only check the current rank.
assert output_directory[0] != output_directory[1]
assert os.path.exists(output_directory[current_rank])
def test_fr7():
"""FR7: Python bindings for launching simulations.
gmx.mdrun uses bindings to C++ API to launch simulations.
"""
md = gmx.mdrun(tprfilename)
md.run()
def test_fr9():
"""FR9: *gmx.mdrun supports interface for binding MD plugins*
(requires interaction with library development)
"""
import sample_restraint
starting_structure = 'input_conf.gro'
topology_file = 'input.top'
run_parameters = 'params.mdp'
initial_tpr = gmx.commandline_operation(
'gmx',
'grompp',
input={
'-f': run_parameters,
'-c': starting_structure,
'-p': topology_file
},
output={'-o': gmx.OutputFile('.tpr')})
simulation_input = gmx.read_tpr(initial_tpr.output.file['-o'])
# Prepare a simple harmonic restraint between atoms 1 and 4
restraint_params = {'sites': [1, 4],
'R0': 2.0,
'k': 10000.0}
restraint = sample_restraint.harmonic_restraint(input=restraint_params)
md = gmx.mdrun(input=simulation_input, potential=sample_restraint)
def test_fr12():
"""FR12: Simulation checkpoint handling
* gmx.mdrun is properly restartable
This should be invisible to the user, and requires introspection and testing infrastructure to properly test (TBD).
"""
from gmxapi import testsupport
simulation_input = gmx.read_tpr(initial_tpr)
md = gmx.mdrun(simulation_input, label='md')
interrupting_context = testsupport.interrupted_md(md)
with interrupting_context as session:
first_half_md = session.md.run()
md = gmx.mdrun(first_half_md, context=testsupport.inspect)
testsupport.verify_restart(md)
def test_fr23():
"""FR23: Ensemble simulations can themselves use MPI
*GROMACS simulation can use a set of subcommunicators from the comm owned by the client.*
(requires interaction with library development)
"""
from mpi4py import MPI
comm_world = MPI.COMM_WORLD
md = gmx.mdrun([tpr_filename for _ in range(2)])
with gmx.get_context(md, communicator=comm_world) as session:
session.run()
md = gmx.mdrun([tpr_filename for _ in range(4)])
with gmx.get_context(md, communicator=comm_world) as session:
session.run()
def test_run_from_modify_input_op(spc_water_box, caplog):
with caplog.at_level(logging.DEBUG):
simulation_input = gmx.read_tpr(spc_water_box)
modified_input = gmx.modify_input(input=simulation_input,
parameters={'nsteps': 4})
md = gmx.mdrun(input=modified_input)
md.run()
def test_run_from_read_tpr_op(spc_water_box, caplog):
with caplog.at_level(logging.DEBUG):
caplog.handler.setFormatter(formatter)
with caplog.at_level(logging.DEBUG, 'gmxapi'):
simulation_input = gmx.read_tpr(spc_water_box)
md = gmx.mdrun(input=simulation_input)
md.run()
if rank_number == 0:
assert os.path.exists(md.output.trajectory.result())
def test_fr23():
"""FR23: Ensemble simulations can themselves use MPI
*GROMACS simulation can use a set of subcommunicators from the comm owned by the client.*
(requires interaction with library development)
"""
from mpi4py import MPI
comm_world = MPI.COMM_WORLD
md = gmx.mdrun([tpr_filename for _ in range(2)])
with gmx.get_context(md, communicator=comm_world) as session:
session.run()
md = gmx.mdrun([tpr_filename for _ in range(4)])
with gmx.get_context(md, communicator=comm_world) as session:
session.run()
def test_fr11():
"""FR11: Python access to TPR file contents.
* gmx.read_tpr utility provides access to TPR file contents
* gmx.read_tpr operation produces output consumable by gmx.mdrun
* gmx.mdrun produces gromacs.read_tpr node for tpr filename kwargs
"""
simulation_input = gmx.read_tpr(initial_tpr)
nsteps = simulation_input.params('nsteps')
md = gmx.mdrun(simulation_input)
assert md.output.trajectory.step.result() == nsteps
def single_run(self, prep, name, log=True):
mdrun = gmx.read_tpr(prep.output.file["-o"])
md = gmx.mdrun(mdrun)
md.run()
path = md.output.trajectory.result()
path = path[:path.rfind("/") + 1]
self.configuration_file = path + "confout.gro"
if log:
self.history.append(path)
self.latest_path = path
shutil.move(name + ".mdp", path + name + ".mdp")
shutil.move(name + ".tpr", path + name + ".tpr")
def test_fr13():
"""FR13: ``run`` module function simplifies user experience
* gmx.run finds and runs operations to produce expected output files
* gmx.run handles ensemble work topologies
* gmx.run handles multi-process execution
* gmx.run safety checks to avoid data loss / corruption
"""
# commandline_operation helper creates a set of operations
# that includes the discovery and execution of the program
# named in `executable`.
md = gmx.mdrun([tprfilename, tprfilename])
gmx.run()
def test_fr13():
"""FR13: ``run`` module function simplifies user experience
* gmx.run finds and runs operations to produce expected output files
* gmx.run handles ensemble work topologies
* gmx.run handles multi-process execution
* gmx.run safety checks to avoid data loss / corruption
"""
# commandline_operation helper creates a set of operations
# that includes the discovery and execution of the program
# named in `executable`.
md = gmx.mdrun([tprfilename, tprfilename])
gmx.run()
def test_fr15():
"""FR15: Simulation input modification.
* *gmx.modify_input produces new (tpr) simulation input in data flow operation*
(requires interaction with library development)
* gmx.make_input dispatches appropriate preprocessing for file or in-memory simulation input.
"""
initial_input = gmx.read_tpr([tpr_filename for _ in range(10)])
tau_t = list([i / 10. for i in range(10)])
param_sweep = gmx.modify_input(input=initial_input,
parameters={'tau_t': tau_t})
md = gmx.mdrun(param_sweep)
for tau_expected, tau_actual in zip(tau_t,
md.output.params['tau_t'].extract()):
assert tau_expected == tau_actual
def test_fr15():
"""FR15: Simulation input modification.
* *gmx.modify_input produces new (tpr) simulation input in data flow operation*
(requires interaction with library development)
* gmx.make_input dispatches appropriate preprocessing for file or in-memory simulation input.
"""
initial_input = gmx.read_tpr([tpr_filename for _ in range(10)])
tau_t = list([i/10. for i in range(10)])
param_sweep = gmx.modify_input(input=initial_input,
parameters={
'tau_t': tau_t
}
)
md = gmx.mdrun(param_sweep)
for tau_expected, tau_actual in zip(tau_t, md.output.params['tau_t'].extract()):
assert tau_expected == tau_actual
def test_fr22():
"""FR22: MPI-based ensemble management from Python
gmx.context can own an MPI communicator and run ensembles of simulations.
"""
from mpi4py import MPI
comm_world = MPI.COMM_WORLD
group2 = comm_world.Get_group().Incl([0,1])
ensemble_comm = comm_world.Create_group(group2)
md = gmx.mdrun([tpr_filename for _ in range(2)])
with gmx.get_context(md, communicator=ensemble_comm) as session:
session.run()
ensemble_comm.Free()
def test_fr22():
"""FR22: MPI-based ensemble management from Python
gmx.context can own an MPI communicator and run ensembles of simulations.
"""
from mpi4py import MPI
comm_world = MPI.COMM_WORLD
group2 = comm_world.Get_group().Incl([0, 1])
ensemble_comm = comm_world.Create_group(group2)
md = gmx.mdrun([tpr_filename for _ in range(2)])
with gmx.get_context(md, communicator=ensemble_comm) as session:
session.run()
ensemble_comm.Free()
def test_fr4():
"""FR4: Dimensionality and typing of named data causes generation of correct work topologies."""
N = 10
simulation_input = gmx.read_tpr(initial_tpr)
# Array inputs imply array outputs.
input_array = gmx.modify_input(
simulation_input, params={'tau-t': [t / 10.0 for t in range(N)]})
md = gmx.mdrun(input_array) # An array of simulations
rmsf = gmx.commandline_operation(
'gmx',
'rmsf',
input={
'-f': md.output.trajectory,
'-s': initial_tpr
},
output={'-o': gmx.FileName(suffix='.xvg')})
def test_fr4():
"""FR4: Dimensionality and typing of named data causes generation of correct work topologies."""
N = 10
simulation_input = gmx.read_tpr(initial_tpr)
# Array inputs imply array outputs.
input_array = gmx.modify_input(
simulation_input, params={'tau-t': [t / 10.0 for t in range(N)]})
md = gmx.mdrun(input_array) # An array of simulations
rmsf = gmx.commandline_operation(
'gmx',
'rmsf',
input={
'-f': md.output.trajectory,
'-s': initial_tpr
},
output={'-o': gmx.FileName(suffix='.xvg')})
def test_fr10():
"""FR10: 10: fused operations for use in looping constructs
* gmx.subgraph fuses operations
* gmx.while creates an operation wrapping a dynamic number of iterations of a subgraph
"""
train = gmx.subgraph(variables={'conformation': initial_input})
with train:
myplugin.training_restraint(label='training_potential',
params=my_dict_params)
modified_input = gmx.modify_input(input=initial_input,
structure=train.conformation)
md = gmx.mdrun(input=modified_input,
potential=train.training_potential)
# Alternate syntax to facilitate adding multiple potentials:
# md.interface.potential.add(train.training_potential)
brer_tools.training_analyzer(
label='is_converged', params=train.training_potential.output.alpha)
train.conformation = md.output.conformation
train_loop = gmx.while_loop(operation=train,
condition=gmx.logical_not(train.is_converged))
def single_run(self, prep, name, log_run=True):
# Runs a prepared MD run
new_path = self.main_path + name + "/"
try:
os.listdir(new_path)
self.configuration_file = new_path + "confout.gro"
self.latest_path = new_path
return
except FileNotFoundError:
pass
mdrun = gmx.read_tpr(prep.output.file["-o"])
md = gmx.mdrun(mdrun)
md.run()
path = md.output.trajectory.result()
#print(path + (2 * "\n") + "result path")
path = path[:path.rfind("/") + 1]
try:
os.mkdir(new_path)
except FileNotFoundError as e:
print(str(e) + (5 * "\n"))
raise DebugException("Super directory non existant")
"""except FileExistsError as e:
print(str(e)+ 5*"\n")
raise DebugException("MD run with duplicate directory")"""
self.configuration_file = new_path + "confout.gro"
if log_run:
self.history.append(new_path)
self.latest_path = new_path
shutil.move(path + "confout.gro", self.configuration_file)
try:
shutil.move(path + "traj_comp.xtc", new_path + "traj_comp.xtc")
except FileNotFoundError:
log(name + ":\nNo traj.xtc found in: " + path + "\nfor: " +
new_path)
shutil.move(name + ".mdp", new_path + name + ".mdp")
shutil.move(name + ".tpr", new_path + name + ".tpr")
#input("Pause")
return path
def test_fr10():
"""FR10: 10: fused operations for use in looping constructs
* gmx.subgraph fuses operations
* gmx.while creates an operation wrapping a dynamic number of iterations of a subgraph
"""
train = gmx.subgraph(variables={'conformation': initial_input})
with train:
myplugin.training_restraint(
label='training_potential',
params=my_dict_params)
modified_input = gmx.modify_input(
input=initial_input, structure=train.conformation)
md = gmx.mdrun(input=modified_input, potential=train.training_potential)
# Alternate syntax to facilitate adding multiple potentials:
# md.interface.potential.add(train.training_potential)
brer_tools.training_analyzer(
label='is_converged',
params=train.training_potential.output.alpha)
train.conformation = md.output.conformation
train_loop = gmx.while_loop(
operation=train,
condition=gmx.logical_not(train.is_converged))
def test_fr8():
"""FR8: gmx.mdrun understands ensemble work."""
md = gmx.mdrun([tprfilename, tprfilename])
md.run()
def test_run_from_tpr(spc_water_box):
assert os.path.exists(spc_water_box)
md = gmx.mdrun(spc_water_box)
md.run()
def test_run_from_read_tpr_op(spc_water_box):
simulation_input = gmx.read_tpr(spc_water_box)
md = gmx.mdrun(input=simulation_input)
md.run()
def test_fr8(spc_water_box):
"""FR8: gmx.mdrun understands ensemble work."""
md = gmx.mdrun([spc_water_box, spc_water_box])
md.run()
import gmxapi as gmx
# import numpy as np
## create tpr file:
## gmx grompp -f md.mdp -c conf.gro -p topol.top -o topol.tpr -maxwarn 3
## numpy and networkx needed for initial testrun
trial_input = gmx.read_tpr("topol.tpr")
md = gmx.mdrun(trial_input)
md.run()
def test_fr8():
"""FR8: gmx.mdrun understands ensemble work."""
md = gmx.mdrun([tprfilename, tprfilename])
md.run()
def main():
print('''Welcome to an automated run of the Gromacs Lysozyme tutorial, this program
should work on most systems containable within the same simulation box.
Some files are necessary for running the program:
- a *.pdb file describing a protein.
- an "ions.mdp" file for the ion placement configurations
- an "minim.mdp" file for energy minimization configurations
- "nvt.mdp" AND "npt.mdp" files for equilibration"
- "md.mdp" for the md run configurations.\n\n
''')
try:
#file_name = select_file("Please type the .pdb files name: ")
file_name = "1aki.pdb"
clean_name = clean_h2o(file_name, False)
out_name = "processed_" + ".".join(file_name.split(".")[:-1]) + ".gro"
box_name = "newbox_" + ".".join(file_name.split(".")[:-1]) + ".gro"
solv_name = "solv_" + ".".join(file_name.split(".")[:-1]) + ".gro"
is_name = "ion_" + solv_name
""" Haven't been able to get this to work lately, meant to delete old backups
might also unintentionally delete valuable work so not very safe. """
sp.run(["rm", "\#*"])
# First command line instruction
pdb2gmx=gmx.commandline_operation(executable = "gmx",
arguments = ["pdb2gmx", "-water", "spce",
"-ff", "oplsaa"],
input_files = {"-f": clean_name},
output_files = {"-o" : out_name})
pdb2gmx.run()
print("pdb2gmx",pdb2gmx.output.erroroutput.result())
file_name = "conf.gro"
box = gmx.commandline_operation(executable ="gmx",
arguments = [ "editconf","-c", "-d", "1.0", "-bt", "cubic"],
input_files = {"-f": pdb2gmx.output.file["-o"]},
output_files= {"-o": box_name})
box.run()
print("box",box.output.erroroutput.result())
""" Until I get a grip on what I'm doing wrong with commandline_operation """
solvate = gmx.commandline_operation(executable = "gmx",
arguments = ["solvate"],
input_files = {"-cp": box.output.file["-o"],
"-p": "topol.top"},
output_files = {"-o": solv_name})
solvate.run()
print("solvate",solvate.output.erroroutput.result())
#ion_name = select_file("Please type the name of you ion .mdp files name")
ion_name = "ions.mdp"
ion_top = ".".join(ion_name.split(".")[:-1]) + ".tpr"
pname = "NA" #get_pname()
nname = "CL" #get_nname()
tpr_assemble = gmx.commandline_operation(executable = "gmx",
arguments = ["grompp"],
input_files = {"-f": ion_name,
"-c": solvate.output.file["-o"],
"-p": "topol.top"},
output_files = {"-o": ion_top})
tpr_assemble.run()
print("tpr_assemble",tpr_assemble.output.erroroutput.result())
#sp.run(["gmx", "genion", "-s", ion_top, "-o", is_name, "-p","topol.top",\
# "-pname", pname, "-nname", nname, "-neutral"], input="SOL", text=True)
genion = gmx.commandline_operation(executable = "gmx",
arguments = ["genion", "-pname", pname, "-nname", nname, "-neutral"],
input_files = {"-s": tpr_assemble.output.file["-o"],
"-p": "topol.top"},
output_files = {"-o": is_name},
stdin = "SOL")
genion.run()
print("genion", genion.output.erroroutput.result())
# Energy minimization
emtprprep = gmx.commandline_operation(executable = "gmx",
arguments = ["grompp"],
input_files = {"-f": "minim.mdp",
"-c": genion.output.file["-o"],
"-p": "topol.top"},
output_files = {"-o": "em.tpr"})
emtprprep.run()
print ("emtprprep", emtprprep.output.erroroutput.result())
#sp.run(["gmx", "grompp", "-f", "minim.mdp", "-c", is_name, "-p", "topol.top",\
# "-o", "em.tpr"])
emtpr = gmx.read_tpr(emtprprep.output.file["-o"])
em = gmx.mdrun(emtpr)
em.run()
#sp.run(["gmx", "mdrun", "-deffnm", "em"])
emgro=em.output.trajectory.result()
emgro=emgro[:emgro.rfind('/') + 1] + "confout.gro"
# Equilibration
eq1tpr = gmx.commandline_operation(executable = "gmx",
arguments = ["grompp"],
input_files = {"-f": "nvt.mdp",
"-c": emgro,
"-r": emgro,
"-p": "topol.top"},
output_files = {"-o": "nvt.tpr"})
eq1tpr.run()
print ("eq1tpr", eq1tpr.output.erroroutput.result())
eq1tp = gmx.read_tpr(eq1tpr.output.file["-o"])
eq1=gmx.mdrun(eq1tp)
eq1.run()
#sp.run(["gmx", "grompp", "-f", "nvt.mdp", "-c", "em.gro", "-r", "em.gro", "-p",\
# "topol.top", "-o", "nvt.tpr"])
#sp.run(["gmx", "mdrun", "-deffnm", "nvt"])
eq1gro=eq1.output.trajectory.result()
eq1gro=eq1gro[:eq1gro.rfind('/') + 1] + "confout.gro"
# Equilibration 2
eq2tpr = gmx.commandline_operation(executable = "gmx",
arguments = ["grompp"],
input_files = {"-f": "npt.mdp",
"-c": eq1gro,
"-r": eq1gro,
"-p": "topol.top"},
output_files = {"-o": "npt.tpr"})
eq2tpr.run()
print ("eq2tpr", eq2tpr.output.erroroutput.result())
eq2tp = gmx.read_tpr(eq2tpr.output.file["-o"])
eq2 = gmx.mdrun(eq2tp)
eq2.run()
eq2out = eq2.output.trajectory.result()
eq2out = eq2out[:eq2out.rfind('/') + 1]
mdtpr = gmx.commandline_operation(executable = "gmx",
arguments = ["grompp"],
input_files = {"-f": "md.mdp",
"-c": eq2out + "confout.gro",
"-t": eq2out + "state.cpt",
"-p": "topol.top"},
output_files = {"-o": "md_0_1.tpr"})
mdtpr.run()
mdtp = gmx.read_tpr(mdtpr.output.file["-o"])
md = gmx.mdrun(mdtp)
md.run()
print("Finished")
# RUN
"""sp.run(["gmx", "grompp", "-f", "md.mdp", "-c", "npt.gro", "-t", "npt.cpt", "-p", \
"topol.top", "-o", "md_0_1.tpr"])
sp.run(["gmx", "mdrun", "-deffnm", "md_0_1"])"""
except stop:
print ("*** Exiting program per users wishes ***")
return
