def add_reporters(self):
self.simulation.reporters.append(PDBReporter("output.pdb", 5000))
if self.configuration.fn_state:
self.simulation.reporters.append(
StateDataReporter(
self.configuration.fn_state,
self.configuration.fr_save,
step=True,
potentialEnergy=True,
kineticEnergy=True,
totalEnergy=True,
temperature=True,
separator=" || ",
volume=True,
density=True,
speed=True,
))
if self.configuration.fn_state:
self.simulation.reporters.append(
DCDReporter(
self.configuration.fn_traj,
self.configuration.fr_save,
))
def run_md_simulation(random_seed, simulation, pdb, args):
if args.SIM_RUN_SIMULATION:
print("Running simulation...")
if args.SIM_SET_INITIAL_VELOCITIES:
print(f" Setting up initial velocities at temperature {args.SIM_TEMP}")
simulation.context.setVelocitiesToTemperature(args.SIM_TEMP, random_seed)
reporting_to_screen_freq = max(1, int(round(args.SIM_N_STEPS / args.REP_STATE_N_SCREEN)))
reporting_to_file_freq = max(1, int(round(args.SIM_N_STEPS / args.REP_STATE_N_FILE)))
trajectory_freq = max(1, int(round(args.SIM_N_STEPS / args.TRJ_FRAMES)))
total_time = args.SIM_N_STEPS * args.SIM_TIME_STEP
print(" Number of steps: {} steps".format(args.SIM_N_STEPS))
print(" Time step: {}".format(args.SIM_TIME_STEP))
print(" Temperature: {}".format(args.SIM_TEMP))
print(" Total simulation time: {}".format(total_time.in_units_of(simtk.unit.nanoseconds)))
print(" Number of state reads: {} reads".format(args.REP_STATE_N_SCREEN))
print(" State reporting to screen every: {} step".format(reporting_to_screen_freq))
print(" State reporting to file every: {} step".format(reporting_to_file_freq))
print(" Number of trajectory frames: {} frames".format(args.TRJ_FRAMES))
print(" Trajectory frame every: {} step".format(trajectory_freq))
print(" Trajectory frame every: {}".format(trajectory_freq * args.SIM_TIME_STEP))
print(' Random seed:', random_seed)
print()
if args.TRJ_FILENAME_PDB:
simulation.reporters.append(PDBReporter(args.TRJ_FILENAME_PDB, trajectory_freq))
if args.TRJ_FILENAME_DCD:
simulation.reporters.append(DCDReporter(args.TRJ_FILENAME_DCD, trajectory_freq))
simulation.reporters.append(StateDataReporter(sys.stdout, reporting_to_screen_freq,
step=True, progress=True, potentialEnergy=True,
totalSteps=args.SIM_N_STEPS))
if args.REP_STATE_FILE_PATH:
simulation.reporters.append(StateDataReporter(args.REP_STATE_FILE_PATH, reporting_to_file_freq,
step=True, potentialEnergy=True))
if args.REP_STATE_FILE_H5_PATH:
simulation.reporters.append(HDF5Reporter(args.REP_STATE_FILE_H5_PATH, reporting_to_file_freq, velocities=True))
print('Running simulation...')
simulation.step(args.SIM_N_STEPS)
if args.TRJ_LAST_FRAME_PDB:
last_frame_file_name = args.TRJ_LAST_FRAME_PDB
state = simulation.context.getState(getPositions=True)
PDBFile.writeFile(pdb.topology, state.getPositions(), open(last_frame_file_name, 'w'))
if args.REP_PLOT_FILE_NAME:
plot_data(args.REP_STATE_FILE_PATH, args.REP_PLOT_FILE_NAME)
atom_subset = None
simulation.reporters.append(
md.reporters.DCDReporter(output_file,
opts['stride'],
atomSubset=atom_subset))
print(
'Writing stride %d to file `%s` with selection `%s`' %
(opts['stride'], opts['filename'], opts['selection']))
else:
# use defaults from arguments
output_file = os.path.join(output, 'output.dcd')
simulation.reporters.append(
DCDReporter(output_file, args.interval_store))
if not args.restart:
# if not a restart write first frame
state = simulation.context.getState(getPositions=True)
for r in simulation.reporters:
r.report(simulation, state)
if args.report and args.verbose:
output_stride = args.interval_store
if types:
output_stride = min([oty['stride'] for oty in types.values()])
simulation.reporters.append(
StateDataReporter(
stdout,
output_stride,
# Loop extrusion force
le_force = mm.HarmonicBondForce()
le_force.addBond(
48, 50, 1 * u.angstrom,
LE_FORCE_MATRIX[2][0] * u.kilocalories_per_mole / u.angstroms**2)
for i in range(2, 35):
p1, p2 = 49 - i, 49 + i
le_force.addBond(
p1, p2, 1 * u.angstrom,
LE_FORCE_MATRIX[1][0] * u.kilocalories_per_mole / u.angstroms**2)
system.addForce(le_force)
simulation = Simulation(pdb.topology, system, integrator)
simulation.context.setPositions(pdb.positions)
simulation.minimizeEnergy()
simulation.reporters.append(DCDReporter('trj.dcd', 1))
simulation.reporters.append(
StateDataReporter(stdout,
1000,
step=True,
potentialEnergy=True,
temperature=True))
simulation.reporters.append(
StateDataReporter(STATE_FNAME, 10, step=True, potentialEnergy=True))
simulation.step(STEPS_PER_CYCLE)
for i in range(2, 35):
p1, p2 = 49 - i, 49 + i
for j in range(0, STEPS_PER_CYCLE):
le_force.setBondParameters(
# noinspection PyCallByClass,PyTypeChecker
print('(%d) %s' % (no_platform, Platform.getPlatform(no_platform).getName()))
print(os.environ)
print(Platform.getPluginLoadFailures())
print(Platform.getDefaultPluginsDirectory())
simulation.context.setPositions(pdb.positions)
pbv = system.getDefaultPeriodicBoxVectors()
simulation.context.setPeriodicBoxVectors(*pbv)
# set velocities to temperature in integrator
temperature = integrator.getTemperature()
dt = integrator.getStepSize()
simulation.context.setVelocitiesToTemperature(temperature)
simulation.reporters.append(StateDataReporter(stdout, 1000, step=True,
potentialEnergy=True, temperature=True))
if args.save_traj=='True':
simulation.reporters.append(DCDReporter(args.path+'/iter'+str(args.iter)+'_traj'+str(i)+'.dcd', args.trajstride))
steps=args.md_steps #1000=2sec each, 10000=20sec
start=datetime.now()
simulation.step(steps)
end = datetime.now()
elapsed = end -start
time=elapsed.seconds + elapsed.microseconds*1e-6
print('Integrated %d steps in %g seconds' % (steps, time))
print('%g ns/day' % (dt*steps*86400/time).value_in_unit(u.nanoseconds))
state = simulation.context.getState(getPositions=True, getVelocities=True,getEnergy=True)
pbv = state.getPeriodicBoxVectors(asNumpy=True)
vel = state.getVelocities(asNumpy=True)
pos = state.getPositions(asNumpy=True)
print(state.getPotentialEnergy(), state.getKineticEnergy())
PDBFile.writeFile(simulation.topology, pos, open(args.path+'/iter'+str(args.iter)+'_out'+str(i)+'.pdb', 'a'))
del simulation, integrator, system
PDBFile.writeFile(
modeller.topology,
context.getState(getPositions=True,
enforcePeriodicBox=False).getPositions(),
file=outfile,
keepIds=True)
# equilibrate
simulation.context.setVelocitiesToTemperature(temperature)
print('Equilibrating ...')
simulation.step(equilibration_steps)
# Run the simulation.
# The enforcePeriodicBox arg to the reporters is important.
# It's a bit counter-intuitive that the value needs to be False, but this is needed to ensure that
# all parts of the simulation end up in the same periodic box when being output.
# simulation.reporters.append(PDBReporter(output_traj_pdb, reporting_interval, enforcePeriodicBox=False))
simulation.reporters.append(
DCDReporter(output_traj_dcd, reporting_interval, enforcePeriodicBox=False))
simulation.reporters.append(
StateDataReporter(sys.stdout,
reporting_interval * 5,
step=True,
potentialEnergy=True,
temperature=True))
print('Starting simulation with', num_steps, 'steps ...')
t0 = time.time()
simulation.step(num_steps)
t1 = time.time()
print('Simulation complete in', t1 - t0, 'seconds at', temperature)
bar_freq = int(MD_steps / print_freq)
integrator = LangevinIntegrator(Temp, 1.0 / unit.picoseconds, dt)
barostat = MonteCarloBarostat(Pres, Temp, 100)
system.addForce(barostat)
# Simulation Object
simulation = Simulation(coords.topology, system, integrator,
Platform.getPlatformByName('CUDA'), {
'CudaDeviceIndex': '0',
'CudaPrecision': 'single'
})
simulation.context.setPositions(coords.positions)
simulation.reporters.append(
DCDReporter(os.path.join('simulations', 'npt_production', 'test.dcd'),
out_freq, False))
simulation.reporters.append(
StateDataReporter(
os.path.join('simulations', 'npt_production', 'test.log'),
out_freq,
step=True,
kineticEnergy=True,
potentialEnergy=True,
totalEnergy=True,
temperature=True,
totalSteps=MD_steps,
progress=True,
remainingTime=True,
speed=True,
separator=",",
))
def loop_extrusion(STEPS, LE_FORCE_SCALE, MATRIX_LENGTH, STEPS_PER_CYCLE, STEPS_PER_IT):
STATE_FNAME = '2sided-state.csv'
#STEPS = 10000
#LE_FORCE_SCALE = 3
#MATRIX_LENGTH = 200
#STEPS_PER_CYCLE = 10
#STEPS_PER_IT = 1
#Macierz z parametrami sił wiązań
#Dodano funkcje generacji macierzy o wartościach sinusoidalnych. Funkcja ta przyjmuje dwa argumenty. Pierwszy oznacza liczbę kroków które ma posiadać macierz a drugi
#stanowi regulacje maksymalnej siły (tzn jeśli wstawimy 3 to maksymalna siła bedzie tyle wynosić)
LE_FORCE_MATRIX = gen_sin_array(MATRIX_LENGTH,LE_FORCE_SCALE)
LE_FORCE_MATRIX[1][0] = 0
LE_FORCE_MATRIX[2][-1] = 0
#print(LE_FORCE_MATRIX)
pdb = PDBFile('initial_structure.pdb')
forcefield = ForceField('polymer_ff.xml')
system = forcefield.createSystem(pdb.topology, nonbondedCutoff=1 * u.nanometer)
integrator = mm.LangevinIntegrator(100 * u.kelvin, 0.2, 1 * u.femtoseconds)
# Distance constraint
for i in range(system.getNumParticles() - 1):
system.addConstraint(i, i + 1, 0.1 * u.nanometer)
# Pinning ends with rubber
pin_force = mm.CustomExternalForce("k*((x-x0)^2+(y-y0)^2+(z-z0)^2)")
pin_force.addGlobalParameter("k", 50 * u.kilocalories_per_mole / u.angstroms ** 2)
pin_force.addPerParticleParameter("x0")
pin_force.addPerParticleParameter("y0")
pin_force.addPerParticleParameter("z0")
pin_force.addParticle(0, [15 * u.angstrom, 0 * u.angstrom, 0 * u.angstrom])
pin_force.addParticle(system.getNumParticles() - 1, [-15 * u.angstrom, 0 * u.angstrom, 0 * u.angstrom])
system.addForce(pin_force)
# Loop extrusion force
le_force = mm.HarmonicBondForce()
le_force.addBond(48, 50, 1 * u.angstrom, LE_FORCE_SCALE * u.kilocalories_per_mole / u.angstroms ** 2)
for i in range(2, 35):
p1, p2 = 49 - i, 49 + i
le_force.addBond(p1, p2, 1 * u.angstrom, 0.000001 * u.kilocalories_per_mole / u.angstroms ** 2)
system.addForce(le_force)
simulation = Simulation(pdb.topology, system, integrator)
simulation.context.setPositions(pdb.positions)
simulation.minimizeEnergy()
simulation.reporters.append(DCDReporter('wyniki/2sided-trj.dcd', 1))
simulation.reporters.append(StateDataReporter(stdout, 1000, step=True, potentialEnergy=True, temperature=True))
simulation.reporters.append(StateDataReporter(STATE_FNAME, 10, step=True, potentialEnergy=True))
simulation.step(1)
for i in range(2, 35):
p1, p2 = 49 - i, 49 + i
for j in range(MATRIX_LENGTH):
le_force_one = LE_FORCE_MATRIX[1][j] * u.kilocalories_per_mole / u.angstroms ** 2 #ROSNĄCA
le_force_two = LE_FORCE_MATRIX[2][j] * u.kilocalories_per_mole / u.angstroms ** 2 #MALEJĄCA
le_force.setBondParameters(i - 2, p1 + 1, p2 - 1, 1 * u.angstrom,
le_force_two)
le_force.setBondParameters(i - 1, p1, p2, 1 * u.angstrom, le_force_one)
le_force.updateParametersInContext(simulation.context)
#print(le_force_one)
#print(le_force_two)
#simulation.minimizeEnergy()
simulation.step(STEPS_PER_IT)
# for i in range(STEPS_PER_CYCLE):
# simulation.step(1)
simulation.step(200)
plot_data(STATE_FNAME, '2sided-energy.png')
print('#1: repr stick; color white; color red :1,100; repr sphere :1,100; vdwdefine 0.5')
print('#1: color green :49,51; repr sphere :49,51; color #ffffa2e8a2e8 :50;')
for i in range(1, 35):
p1, p2 = 50 - i - 1, 50 + i + 1
print(
f'#{i*STEPS_PER_CYCLE+1}: color green :{p1},{p2}; repr sphere :{p1},{p2}; repr stick :{p1+1},{p2-1}; color #ffffa2e8a2e8 :{p1+1}-{p2-1};')
print("Done")
saveFrequency=250,
biasDir='./biases')
integrator = mm.LangevinIntegrator(temperature, 1.0 / unit.picosecond,
0.004 * unit.picoseconds)
print("Done specifying integrator.")
simulation = Simulation(molecule.topology, system, integrator)
simulation.context.setPositions(pdb.positions)
print("Done specifying simulation.")
# equilibration
simulation.context.setVelocitiesToTemperature(temperature)
simulation.step(100)
print("Done 100 steps of equilibration.")
# set simulation reporters
simulation.reporters.append(DCDReporter('mtd_2JIU.dcd', reportInterval=250))
simulation.reporters.append(
StateDataReporter('mtd_2JIU.out',
reportInterval=5000,
step=True,
potentialEnergy=True,
temperature=True,
progress=True,
remainingTime=True,
speed=True,
totalSteps=10000000,
separator='\t'))
# Run small-scale simulation (20ns, 10^7 steps) and plot the free energy landscape
meta.step(simulation, 10000000)
#plot.imshow(meta.getFreeEnergy())
biasDir='./biases')
integrator = mm.LangevinIntegrator(310.15 * unit.kelvin, 1.0 / unit.picosecond,
0.002 * unit.picoseconds)
print("Done specifying integrator.")
simulation = Simulation(molecule.topology, system, integrator)
print("Done specifying simulation.")
simulation.context.setPositions(positions)
print("Done setting up the simulation.")
# equilibration
simulation.context.setVelocitiesToTemperature(310.15 * unit.kelvin)
simulation.step(100)
print("Done 100 steps of equilibration.")
# set simulation reporters
simulation.reporters.append(DCDReporter('mtd_5UG9.dcd', 5000))
simulation.reporters.append(
StateDataReporter('mtd_5UG9.out',
5000,
step=True,
potentialEnergy=True,
temperature=True,
progress=True,
remainingTime=True,
speed=True,
totalSteps=5000000,
separator='\t'))
# Run small-scale simulation (10ns, 5*10^6 steps) and plot the free energy landscape
meta.step(simulation, 5000000)
#plot.imshow(meta.getFreeEnergy())
def reporter(self):
from simtk.openmm.app import DCDReporter
return DCDReporter(self.file,
self.reportInterval,
append=self.append,
enforcePeriodicBox=self.enforcePeriodicBox)
# all parts of the simulation end up in the same periodic box when being output.
simulation.context.setVelocitiesToTemperature(opt.temp)
simulation.reporters.append(
parmed.openmm.StateDataReporter(opt.output,
reportInterval=opt.interval,
volume=True,
density=True,
separator='\t'))
simulation.reporters.append(
parmed.openmm.ProgressReporter(
str(opt.output) + '.info', opt.interval, opt.num_steps))
simulation.reporters.append(
#parmed.openmm.NetCDFReporter(opt.trajectory, opt.interval*10)
DCDReporter(opt.trajectory, opt.interval * 10, enforcePeriodicBox=False))
#simulation.reporters.append(
# parmed.openmm.RestartReporter(opt.restart, opt.interval*100, netcdf=True)
#)
print('Starting simulation with', opt.num_steps, 'steps ...')
#simulation.context.setPositions(modeller.positions)
#simulation.context.setVelocitiesToTemperature(opt.temp)
t0 = time.time()
simulation.step(opt.num_steps)
t1 = time.time()
print('Simulation complete in', t1 - t0, 'seconds at', opt.temp * unit.kelvin)
import mdtraj as md
def main(argdict):
""" Main function for entry point checking.
Expects a dictionary of command line arguments.
"""
# are we continuing from logfile or starting from fresh PDB?
if argdict["log"] is None:
# keep track of restart number:
argdict["restart_number"] = int(0)
# write arguments to a file to keep a record:
with open(argdict["outname"] + "_parameters.log", 'w') as f:
print(json.dumps(argdict, sort_keys=True, indent=4), file=f)
else:
# load configuration from logfile:
logfile = argdict["log"]
with open(argdict["log"], 'r') as f:
argdict = json.load(f)
# make sure log file has appropriate entry:
argdict["log"] = logfile
# increment restart number:
argdict["restart_number"] += 1
# write unnumbered parameters file (for easy restarts):
with open(argdict["outname"] + "_parameters.log", 'w') as f:
print(json.dumps(argdict, sort_keys=True, indent=4), file=f)
# write numbered parameters file (for record keeping):
with open(
argdict["outname"] + "_" + str(argdict["restart_number"]) +
"_parameters.log", 'w') as f:
print(json.dumps(argdict, sort_keys=True, indent=4), file=f)
# load system initial configuration:
pdb = pdb_file_nonstandard_bonds(argdict["pdb"])
print("--> input topology: ", end="")
print(pdb.topology)
# get XML file from absolute path:
xmlfile = os.path.abspath(argdict["xml"])
# set box size in topology to values from XML file:
box_vectors = periodic_box_vectors_from_xml(xmlfile)
pdb.topology.setPeriodicBoxVectors(box_vectors)
# physical parameters of simulation:
sim_temperature = argdict["temperature"] * kelvin
sim_andersen_coupling = 1 / picosecond
sim_pressure = (
(argdict["pressure"], argdict["pressure"], argdict["pressure"]) * bar)
sim_scale_x = True
sim_scale_y = True
sim_scale_z = True
# simulation control parameters:
sim_timestep = argdict["timestep"] * femtoseconds
sim_num_steps = argdict["num_steps"]
sim_traj_rep_steps = argdict["report_freq"]
sim_state_rep_steps = argdict["report_freq"]
sim_checkpoint_steps = argdict["report_freq"]
# restraints parameters:
sim_restr_fc = argdict["restr_fc"] * kilojoule_per_mole / nanometer**2
# create force field object:
ff = ForceField(*argdict["ff"])
# build a simulation system from topology and force field:
# (note that AMOEBA is intended to be run without constraints)
# (note that mutualInducedtargetEpsilon defaults to 0.01 unlike what is
# specified in the documentation which claims 0.00001)
sys = ff.createSystem(
pdb.topology,
nonbondedMethod=PME,
nonbondedCutoff=argdict["nonbonded_cutoff"] * nanometer,
vdwCutoff=argdict["vdw_cutoff"] * nanometer,
ewaldErrorTolerance=argdict["ewald_error_tolerance"],
polarisation=argdict["polarisation"],
mutualInducedTargetEpsilon=argdict["mutual_induced_target_epsilon"],
constraints=None,
rigidWater=False,
removeCMMotion=True # removes centre of mass motion
)
# overwrite the polarisation method set at system creation; this is
# necessary as openMM always sets polarisation method to "mutual" of the
# target epsilon is specified at system creation; this way, target epsilon
# is ignored for all but the mutual method
multipole_force = sys.getForce(9)
print("--> using polarisation method " + str(argdict["polarisation"]))
if argdict["polarisation"] == "mutual":
multipole_force.setPolarizationType(multipole_force.Mutual)
elif argdict["polarisation"] == "extrapolated":
multipole_force.setPolarizationType(multipole_force.Extrapolated)
elif argdict["polarisation"] == "direct":
multipole_force.setPolarizationType(multipole_force.Direct)
else:
raise Exception("Polarisation method " + str(argdict["polarisation"]) +
" not supported!")
# will use Andersen thermostat here:
# (Inhibits particle dynamics somewhat, but little or no ergodicity
# issues (from Gromacs documenation). However, only alternative is full
# Langevin dynamics, which is even worse wrt dynamics. Bussi/v-rescale is
# not available at the moment, it seems (it is available in tinker, but
# without GPU acceleration))
sys.addForce(AndersenThermostat(sim_temperature, sim_andersen_coupling))
# use anisotropic barostat:
# (note that this corresponds to semiisotropic pressure coupling in Gromacs
# if the pressure is identical for the x- and y/axes)
# (note that by default this attempts an update every 25 steps)
sys.addForce(
MonteCarloAnisotropicBarostat(sim_pressure, sim_temperature,
sim_scale_x, sim_scale_y, sim_scale_z))
# prepare harmonic restraining potential:
# (note that periodic distance is absolutely necessary here to prevent
# system from blowing up, as otherwise periodic image position may be used
# resulting in arbitrarily large forces)
force = CustomExternalForce("k*periodicdistance(x, y, z, x0, y0, z0)^2")
force.addGlobalParameter("k", sim_restr_fc)
force.addPerParticleParameter("x0")
force.addPerParticleParameter("y0")
force.addPerParticleParameter("z0")
# apply harmonic restraints to C-alphas:
if argdict["restr"] == "capr":
print("--> applying harmonic positional restraints to CA atoms")
for atm in pdb.topology.atoms():
if atm.name == "CA":
force.addParticle(atm.index, pdb.positions[atm.index])
elif argdict["restr"] == "hapr":
sys.exit("Restraints mode " + str(argdict["restr"]) +
"is not implemented.")
elif argdict["restr"] == "none":
print("--> applying no harmonic positional restraints to any atom")
else:
sys.exit("Restraints mode " + str(argdict["restr"]) +
"is not implemented.")
# add restraining force to system:
sys.addForce(force)
# make special group for nonbonded forces:
for f in sys.getForces():
if (isinstance(f, AmoebaMultipoleForce)
or isinstance(f, AmoebaVdwForce)
or isinstance(f, AmoebaGeneralizedKirkwoodForce)
or isinstance(f, AmoebaWcaDispersionForce)):
f.setForceGroup(1)
# read umbrella parameters from file:
with open(argdict["umbrella_target"], "r") as f:
umbrella_target = json.load(f)
# obtain index from atom to be restrained:
umbrella_index = umbrella_target["target_particle"]["index"]
umbrella_fc = (umbrella_target["umbrella_params"]["fc"] *
kilojoule_per_mole / nanometer**2)
umbrella_cv = umbrella_target["umbrella_params"]["cv"] * nanometer
# inform user:
print("--> applying umbrella potential to " +
str(list(pdb.topology.atoms())[umbrella_index]) + " at position " +
str(pdb.positions[umbrella_index]))
# additional restraining force applied to ion under umbrella restraints:
umbrella_force = CustomExternalForce(
"k*periodicdistance(0.0, 0.0, z, 0.0, 0.0, z0)^2")
umbrella_force.addGlobalParameter("k", umbrella_fc)
# z0 is set to value in JSON file rather than initial particle coordinate to
# allow for a few steps of energy minimisation to avoid clashes between the
# restrained umbrella target and surrounding atoms:
umbrella_force.addGlobalParameter("z0", umbrella_cv)
# select integrator:
if argdict["integrator"] == "mts":
# use multiple timestep RESPA integrator:
print("--> using RESPA/MTS integrator")
integrator = MTSIntegrator(sim_timestep,
[(0, argdict["inner_ts_frac"]), (1, 1)])
elif argdict["integrator"] == "verlet":
# use Leapfrog Verlet integrator here:
print("--> using Verlet integrator")
integrator = VerletIntegrator(sim_timestep)
else:
# no other integrators supported:
raise Exception("Integrator " + str(argdict["integrator"]) +
" is not supported.")
# select a platform:
platform = Platform.getPlatformByName(argdict["platform"])
properties = {
"CudaPrecision": argdict["precision"],
"CudaDeviceIndex": "0"
}
# prepare a simulation from topology, system, and integrator and set initial
# positions as in PDB file:
sim = Simulation(pdb.topology, sys, integrator, platform, properties)
# is this initial simulation or restart from checkpoint?
if argdict["log"] is None:
# load positions and velocities from XML file:
print("--> loading simulation state from XML file...")
sim.loadState(xmlfile)
# find all particles bonded to ion (i.e. Drude particles):
idx_bonded = atom_idx_from_bonds(sim.topology, umbrella_index)
idx_shift = idx_bonded + [umbrella_index]
# shift target particle into position:
pos = (sim.context.getState(getPositions=True).getPositions(
asNumpy=True))
pos[idx_shift, :] = (umbrella_target["target_particle"]["init_pos"] *
nanometer)
print("--> target particle now placed at " + str(pos[idx_shift, :]))
# set new particle positions in context:
sim.context.setPositions(pos)
e_pot = sim.context.getState(getEnergy=True).getPotentialEnergy()
print("--> potential energy after target placement is: " + str(e_pot))
# minimise energy to remove clashes:
# (too many steps might ruin everythin!)
print("--> running energy minimisation...")
sim.minimizeEnergy(maxIterations=argdict["minimisation_steps"])
e_pot = sim.context.getState(getEnergy=True).getPotentialEnergy()
print(
"--> " + str(argdict["minimisation_steps"]) +
" steps of energy minimisation reduced the potential energy to " +
str(e_pot))
# reduce time step for equilibration period:
print("--> running equilibration at reduced time step...")
sim.integrator.setStepSize(0.1 * sim.integrator.getStepSize())
sim.context.setTime(0.0 * picosecond)
# will write report about equilibration phase:
sim.reporters.append(
StateDataReporter(stdout,
int(argdict["equilibration_steps"] / 10),
step=True,
time=True,
speed=True,
progress=True,
remainingTime=True,
totalSteps=argdict["equilibration_steps"],
separator="\t"))
# run equilibration steps:
sim.step(argdict["equilibration_steps"])
# reset step size to proper value:
sim.integrator.setStepSize(10.0 * sim.integrator.getStepSize())
sim.context.setTime(0.0 * picosecond)
sim.reporters.clear()
else:
# load checkpoint file:
checkpoint_file = (str(argdict["outname"]) + "_" +
str(argdict["restart_number"] - 1) + ".chk")
print("--> loading checkpoint file " + checkpoint_file)
sim.loadCheckpoint(checkpoint_file)
# write collective variable value to file:
sample_outname = (argdict["outname"] + "_" +
str(argdict["restart_number"]) + str(".dat"))
sim.reporters.append(
CollectiveVariableReporter(sample_outname, argdict["umbrella_freq"],
umbrella_index))
# write simulation trajectory to DCD file:
dcd_outname = (argdict["outname"] + "_" + str(argdict["restart_number"]) +
str(".dcd"))
sim.reporters.append(DCDReporter(dcd_outname, sim_traj_rep_steps))
# write state data to tab-separated CSV file:
state_outname = (argdict["outname"] + "_" +
str(argdict["restart_number"]) + str(".csv"))
sim.reporters.append(
StateDataReporter(state_outname,
sim_state_rep_steps,
step=True,
time=True,
progress=False,
remainingTime=True,
potentialEnergy=True,
kineticEnergy=True,
totalEnergy=True,
temperature=True,
volume=True,
density=False,
speed=True,
totalSteps=sim_num_steps,
separator="\t"))
# write limited state information to standard out:
sim.reporters.append(
StateDataReporter(stdout,
sim_state_rep_steps,
step=True,
time=True,
speed=True,
progress=True,
remainingTime=True,
totalSteps=sim_num_steps,
separator="\t"))
# write checkpoint files regularly:
checkpoint_outname = (argdict["outname"] + "_" +
str(argdict["restart_number"]) + ".chk")
sim.reporters.append(
CheckpointReporter(checkpoint_outname, sim_checkpoint_steps))
# run simulation:
sim.step(argdict["num_steps"])
# save final simulation state:
sim.saveState(argdict["outname"] + "_" + str(argdict["restart_number"]) +
".xml")
positions = sim.context.getState(getPositions=True).getPositions()
PDBFile.writeFile(
sim.topology, positions,
open(
argdict["outname"] + "_" + str(argdict["restart_number"]) + ".pdb",
"w"))
# system.addForce(openmm.MonteCarloBarostat(1*unit.atmospheres, temperature, 25))
print('Uses Periodic box:', system.usesPeriodicBoundaryConditions(),
', Default Periodic box:', system.getDefaultPeriodicBoxVectors())
simulation = Simulation(modeller.topology, system, integrator, platform=platform)
simulation.context.setPositions(modeller.positions)
print('Minimising ...')
simulation.minimizeEnergy()
# write out the minimised PDB
with open(output_min, 'w') as outfile:
PDBFile.writeFile(modeller.topology, simulation.context.getState(getPositions=True, enforcePeriodicBox=False).getPositions(), file=outfile, keepIds=True)
# equilibrate
simulation.context.setVelocitiesToTemperature(temperature)
print('Equilibrating ...')
simulation.step(equilibration_steps)
# Run the simulation.
# The enforcePeriodicBox arg to the reporters is important.
# It's a bit counter-intuitive that the value needs to be False, but this is needed to ensure that
# all parts of the simulation end up in the same periodic box when being output.
# simulation.reporters.append(PDBReporter(output_traj_pdb, reporting_interval, enforcePeriodicBox=False))
simulation.reporters.append(DCDReporter(output_traj_dcd, reporting_interval, enforcePeriodicBox=False))
simulation.reporters.append(StateDataReporter(sys.stdout, reporting_interval * 5, step=True, potentialEnergy=True, temperature=True))
print('Starting simulation with', num_steps, 'steps ...')
t0 = time.time()
simulation.step(num_steps)
t1 = time.time()
print('Simulation complete in', t1 - t0, 'seconds at', temperature)
