openmm.Platform.getPlatformByName(name),
dict(Precision='mixed') if name == 'CUDA' else dict()
]
integrator = openmm.LangevinIntegrator(temp, 0.1 / unit.femtoseconds,
1.0 * unit.femtosecond)
system.addForce(openmm.MonteCarloBarostat(1 * unit.atmospheres, temp, 20))
simulation = app.Simulation(topology, system, integrator,
*platform(simulation_platform))
simulation.context.setPositions(modeller.getPositions())
simulation.context.setVelocitiesToTemperature(temp)
computer = atomsmm.PressureComputer(system, topology,
*platform(pressure_computer_platform))
reporter = atomsmm.ExtendedStateDataReporter(stdout,
100,
step=True,
speed=True,
potentialEnergy=True,
temperature=True,
density=True,
atomicPressure=(not rigid_water),
molecularPressure=True,
pressureComputer=computer,
extraFile='properties.csv')
simulation.reporters.append(reporter)
simulation.minimizeEnergy()
simulation.step(100000)
simulation.context.setPositions(pdb.positions)
simulation.context.setVelocitiesToTemperature(temp, seed)
states_file = 'alchemical_states' + ('.inp' if args.part == 0 else
f'_{args.part}.inp')
states_data = pd.read_csv(states_file, sep='\s+', comment='#')
parameterStates = states_data[['lambda_vdw', 'lambda_coul']]
simulate = states_data['weight'] != -np.inf
for state in reversed(states_data.index):
if simulate[state]:
for name, value in parameterStates.iloc[state].items():
simulation.context.setParameter(name, value)
print(f'{name} = {value}')
dataReporter = atomsmm.ExtendedStateDataReporter(
stdout,
reportInterval,
separator=',',
step=True,
potentialEnergy=True,
temperature=True,
speed=True,
extraFile=f'{base}_data-{state:02d}.csv')
multistateReporter = atomsmm.ExtendedStateDataReporter(
f'{base}_energy-{state:02d}.csv',
reportInterval,
separator=',',
step=True,
globalParameterStates=parameterStates)
simulation.reporters = [dataReporter, multistateReporter]
simulation.step(steps_per_state)
platform, properties)
simulation.context.setPositions(pdb.positions)
simulation.context.setVelocitiesToTemperature(temp, seed)
states_data = pd.read_csv('expanded_ensemble_states.inp',
sep='\s+',
comment='#')
parameterStates = states_data[['lambda_vdw', 'lambda_coul']]
state = len(states_data.index) - 1
for name, value in parameterStates.iloc[state].items():
simulation.context.setParameter(name, value)
print(f'{name} = {value}')
dataReporter = atomsmm.ExtendedStateDataReporter(stdout,
reportInterval,
separator=',',
step=True,
potentialEnergy=True,
temperature=True,
speed=True,
extraFile=f'{base}_data.csv')
expandedEnsembleReporter = atomsmm.reporters.ExpandedEnsembleReporter(
f'{base}_energy.csv',
reportInterval,
separator=',',
states=states_data,
temperature=temp)
simulation.reporters = [dataReporter, expandedEnsembleReporter]
simulation.step(args.nsteps)
expandedEnsembleReporter.state_sampling_analysis()
expandedEnsembleReporter.walking_time_analysis()
pdb.topology,
# openmm.Platform.getPlatformByName('CPU'),
openmm.Platform.getPlatformByName('CUDA'),
dict(Precision='mixed', DeviceIndex=args.secdev),
temperature=temp)
dataReporter = atomsmm.ExtendedStateDataReporter(
stdout,
reportInterval,
separator=',',
step=True,
potentialEnergy=True,
kineticEnergy=True,
# totalEnergy=True,
temperature=True,
# atomicVirial=True,
atomicPressure=True,
# nonbondedVirial=True,
# molecularVirial=True,
molecularPressure=True,
# molecularKineticEnergy=True,
# coulombEnergy=True,
pressure_computer=computer,
time_scales=(3 if args.timestep > 3 else 2),
speed=True,
extraFile=f'{base}.csv')
configReporter = atomsmm.XYZReporter(f'{base}.xyz', 4 * reportInterval)
simulation.reporters += [dataReporter, configReporter]
simulation.step(args.nsteps)
openmm_system.addForce(
openmm.MonteCarloBarostat(1 * unit.atmospheres, temp, 25))
integrator = openmm.LangevinIntegrator(temp, 1.0 / unit.picoseconds,
1.0 * unit.femtosecond)
simulation = openmm.app.Simulation(pdb.topology, openmm_system, integrator,
platform, properties)
simulation.context.setPositions(pdb.positions)
simulation.context.setVelocitiesToTemperature(temp, seed)
reporter = atomsmm.ExtendedStateDataReporter(stdout,
reportInterval,
separator=',',
step=True,
potentialEnergy=True,
kineticEnergy=True,
totalEnergy=True,
temperature=True,
volume=True,
density=True,
speed=True,
extraFile='properties.csv')
simulation.reporters.append(reporter)
simulation.step(nsteps)
state = simulation.context.getState(getPositions=True)
coords = state.getPositions(asNumpy=True).value_in_unit(unit.angstroms)
volume = state.getPeriodicBoxVolume().value_in_unit(unit.angstroms**3)
Lbox = [volume**(1 / 3)] * 3
out = open('box.temp', 'w')
print('box lengths {} {} {}'.format(*Lbox), file=out)
nbforce.setUseSwitchingFunction(True)
nbforce.setSwitchingDistance(rswitch)
nbforce.setUseDispersionCorrection(True)
Nd = 3 * (openmm_system.getNumParticles() - 1)
# integrator = my_integrators.MiddleNoseHooverChainIntegrator(dt, temp, tau, Nd)
integrator = my_integrators.MiddleNoseHooverLangevinIntegrator(
dt, temp, gamma, tau, Nd)
simulation = openmm.app.Simulation(pdb.topology, openmm_system, integrator,
platform, properties)
simulation.context.setPositions(pdb.positions)
simulation.context.setVelocitiesToTemperature(temp, seed)
dataReporter = atomsmm.ExtendedStateDataReporter(stdout,
reportInterval,
separator=',',
step=True,
potentialEnergy=True,
kineticEnergy=True,
totalEnergy=True,
temperature=True,
speed=True,
extraFile=f'{args.file}.csv')
comReporter = atomsmm.CenterOfMassReporter(f'{args.file}.xyz', reportInterval)
velReporter = atomsmm.CenterOfMassReporter(f'{args.file}.vel',
reportInterval,
velocities=True)
simulation.reporters += [dataReporter, comReporter, velReporter]
simulation.step(args.nsteps)
properties['DeviceIndex'] = args.device
pdb = app.PDBFile('water.pdb')
forcefield = app.ForceField('water.xml')
openmm_system = forcefield.createSystem(pdb.topology,
nonbondedMethod=openmm.app.PME,
nonbondedCutoff=rcut,
rigidWater=False,
removeCMMotion=False)
nbforce = openmm_system.getForce(atomsmm.findNonbondedForce(openmm_system))
nbforce.setUseSwitchingFunction(True)
nbforce.setSwitchingDistance(rswitch)
nbforce.setUseDispersionCorrection(True)
integrator = openmm.CustomIntegrator(0)
simulation = openmm.app.Simulation(pdb.topology, openmm_system, integrator, platform, properties)
simulation.context.setPositions(pdb.positions)
dataReporter = atomsmm.ExtendedStateDataReporter(stdout, 1, separator=',',
step=True,
potentialEnergy=True,
kineticEnergy=True,
totalEnergy=True,
temperature=True,
speed=True)
simulation.reporters += [dataReporter]
simulation.step(1)
if isinstance(force, openmm.NonbondedForce):
force.setReciprocalSpaceForceGroup(1)
force.setForceGroup(1)
loops = [2*args.timestep, 1]
#integrator = atomsmm.integrators.LimitedSpeedStochasticVelocityIntegrator(dt, loops, temp, tau, gamma, L=args.L)
integrator = atomsmm.integrators.LimitedSpeedStochasticIntegrator(dt, loops, temp, tau, gamma, L=args.L)
simulation = openmm.app.Simulation(pdb.topology, respa_system, integrator, platform, properties)
simulation.context.setPositions(pdb.positions)
simulation.context.setVelocitiesToTemperature(temp, seed)
computer = atomsmm.PressureComputer(openmm_system,
pdb.topology,
openmm.Platform.getPlatformByName('CPU'),
# dict(Precision='mixed', DeviceIndex=args.secdev),
temperature=temp)
dataReporter = atomsmm.ExtendedStateDataReporter(stdout, reportInterval, separator=',',
step=True,
potentialEnergy=True,
temperature=True,
# atomicPressure=True,
# molecularPressure=True,
# pressureComputer=computer,
speed=True,
extraFile=f'{base}.csv')
simulation.reporters += [dataReporter]
simulation.step(args.nsteps)
