def test_update_param_struct_cont(self):
""" Tests that update parameter updates assigned parameters in the structure """
param = CharmmParameterSet(get_fn('top_all36_cgenff.rtf'),
get_fn('par_all36_cgenff.prm'))
structure = get_fn('butane.psf')
logfiles = get_fn('MP2_torsion_scan/')
frag = qmdb.parse_psi4_out(logfiles, structure)
frag = frag.remove_nonoptimized()
to_optimize = [('CG331', 'CG321', 'CG321', 'CG331')]
model = TorsionFitModelOMM(param=param,
frags=frag,
param_to_opt=to_optimize,
sample_phase=True,
continuous_phase=True)
par.update_param_from_sample(model.parameters_to_optimize,
param,
model=model,
rj=model.rj,
phase=model.sample_phase,
n_5=model.sample_n5,
model_type='openmm')
torsion = frag.structure.dihedrals[0]
self.assertEqual(
torsion.type,
param.dihedral_types[(torsion.atom1.type, torsion.atom2.type,
torsion.atom3.type, torsion.atom4.type)])
def test_par_parameters(self, ethane):
ethane.save(filename='ethane-opls.par', forcefield_name='oplsaa')
from parmed.charmm import CharmmParameterSet
pset = CharmmParameterSet.load_set(pfile='ethane-opls.par')
assert len(pset.bond_types) == 3
assert len(pset.angle_types) == 3
assert len(pset.atom_types) == 2
def __init__(self, true_value=None, initial_value=None, n_increments=18, rj=True, sample_phase=False,
continuous=False):
self._param = CharmmParameterSet(get_fun('toy.str'))
self._struct = CharmmPsfFile(get_fun('toy.psf'))
self._pdb = app.PDBFile(get_fun('toy.pdb'))
self._topology = md.load_psf(get_fun('toy.psf'))
self.synthetic_energy = units.Quantity()
self._positions = units.Quantity()
self._platform = mm.Platform.getPlatformByName('Reference')
# Replace ('CG331', 'CG321', 'CG321', 'CG331') torsion with true_value
self._dih_type = ('CG331', 'CG321', 'CG321', 'CG331')
original_torsion = self._param.dihedral_types[self._dih_type]
if true_value is not None:
if type(true_value) == DihedralTypeList:
dih_tlist = true_value
elif type(true_value) == DihedralType:
dih_tlist = DihedralTypeList()
dih_tlist.append(true_value)
else:
dih_tlist = self._randomize_dih_param(return_dih=True)
self.true_value = copy.deepcopy(dih_tlist)
self._param.dihedral_types[self._dih_type] = dih_tlist
# parametrize toy
self._struct.load_parameters(self._param, copy_parameters=False)
self._struct.positions = self._pdb.positions
# generate synthetic torsion scan
self._torsion_scan(n_increments=n_increments)
# initialize parameter
if initial_value is not None:
if type(initial_value) == DihedralTypeList:
dih_tlist = initial_value
if type(initial_value) == DihedralType:
dih_tlist = DihedralTypeList()
dih_tlist.append(initial_value)
elif initial_value == 'cgenff':
dih_tlist = original_torsion
else:
dih_tlist = self._randomize_dih_param(return_dih=True)
self.initial_value = copy.deepcopy(dih_tlist)
self._param.dihedral_types[self._dih_type] = dih_tlist
# create torsionfit.TorsionScanSet
torsions = np.zeros((len(self._positions), 4))
torsions[:] = [1, 2, 3, 4]
direction = None
steps = None
self.scan_set = ScanSet.QMDataBase(positions=self._positions.value_in_unit(units.nanometers),
topology=self._topology, structure=self._struct, torsions=torsions,
steps=steps, directions=direction,
qm_energies=self.synthetic_energy.value_in_unit(units.kilojoules_per_mole))
self.model = model.TorsionFitModel(param=self._param, frags=self.scan_set, platform=self._platform,
param_to_opt=[self._dih_type], rj=rj, continuous_phase=continuous,
sample_phase=sample_phase)
def test_create_simple_system(self):
psf = CharmmPsfFile(get_fn("ala3_solv_drude.psf"))
crd = CharmmCrdFile(get_fn("ala3_solv_drude.crd"))
params = CharmmParameterSet(
get_fn("toppar_drude_master_protein_2013e.str"))
system = psf.createSystem(params)
def test_copy_torsions(self):
""" Test copy torsions"""
structure = get_fn('butane.psf')
scan = get_fn('MP2_torsion_scan/')
test_scan = qmdb.parse_psi4_out(scan, structure)
param = CharmmParameterSet(get_fn('top_all36_cgenff.rtf'),
get_fn('par_all36_cgenff.prm'))
test_scan.compute_energy(param)
test_scan.copy_torsions()
def test_create_context(self):
""" Test create context """
structure = get_fn('butane.psf')
scan = get_fn('MP2_torsion_scan/')
test_scan = qmdb.parse_psi4_out(scan, structure)
param = CharmmParameterSet(get_fn('top_all36_cgenff.rtf'),
get_fn('par_all36_cgenff.prm'))
test_scan.integrator = mm.VerletIntegrator(0.004 * u.picoseconds)
test_scan.create_context(param)
def test_to_optimize(self):
"""Tests generate to_optimize list"""
param = CharmmParameterSet(get_fn('top_all36_cgenff.rtf'),
get_fn('par_all36_cgenff.prm'))
stream = (get_fn('PRL.str'))
to_optimize = qmdb.to_optimize(param, stream)
self.assert_(len(to_optimize) == 19)
reverse = tuple(reversed(to_optimize[0]))
self.assert_(reverse not in to_optimize)
def __init__(self,
psf_filepath,
param_filepath,
crds=None,
positions=None):
super(Molecule, self).__init__()
self.psf = pmd.load_file(psf_filepath)
self.params = CharmmParameterSet(param_filepath)
self.crds = crds
self.initialize(positions)
def generate_nonbonded_params(self):
"""
Obtains non-bonded parameters for each atom in the system.
"""
# use parmed to get parameters
self.water_sites = self.wat_oxygen_atom_ids[1] - self.wat_oxygen_atom_ids[0]
vdw = []
chg = []
if self.supporting_file.endswith(".txt"):
nb_data = np.loadtxt(self.supporting_file)
for c in nb_data[:, 0]:
chg.append(c)
for v in nb_data[:, 1:]:
vdw.append(v)
chg = np.asarray(chg)
elif self.topology_file.endswith(".psf"):
parmed_topology_object = pmd.load_file(self.topology_file)
param_dir = os.path.abspath(self.supporting_file)
param_files = [os.path.join(param_dir, f) for f in os.listdir(param_dir)
if os.path.isfile(os.path.join(param_dir, f)) and f.endswith((".rtf", ".top", ".par", ".prm", ".inp", ".str"))]
params = CharmmParameterSet(*param_files)
try:
parmed_topology_object.load_parameters(params)
except Exception as e:
print(e)
for at in self.all_atom_ids:
vdw.append([parmed_topology_object.atoms[at].sigma,
parmed_topology_object.atoms[at].epsilon])
chg.append(parmed_topology_object.atoms[at].charge)
# .prmtop, .gro, .
else:
parmed_topology_object = pmd.load_file(self.supporting_file)
for at in self.all_atom_ids:
vdw.append([parmed_topology_object.atoms[at].sigma,
parmed_topology_object.atoms[at].epsilon])
chg.append(parmed_topology_object.atoms[at].charge)
# User provided charges are supposed to be in correct units.
if not self.supporting_file.endswith(".txt"):
chg = np.asarray(chg) * 18.2223
vdw = np.asarray(vdw)
water_chg = chg[self.wat_atom_ids[0:self.water_sites]].reshape(self.water_sites, 1)
self.chg_product = water_chg * np.tile(chg[self.all_atom_ids], (self.water_sites, 1))
water_sig = vdw[self.wat_atom_ids[0:self.water_sites], 0].reshape(self.water_sites, 1)
water_eps = vdw[self.wat_atom_ids[0:self.water_sites], 1].reshape(self.water_sites, 1)
self.acoeff, self.bcoeff = self.apply_combination_rules(water_sig, water_eps, vdw, self.comb_rule)
"""
def test_compute_energy(self):
""" Tests compute mm energy"""
structure = get_fn('butane.psf')
scan = get_fn('MP2_torsion_scan/')
test_scan = qmdb.parse_psi4_out(scan, structure, pattern="*.out2")
param = CharmmParameterSet(get_fn('top_all36_cgenff.rtf'),
get_fn('par_all36_cgenff.prm'))
self.assertFalse(test_scan._have_mm_energy)
scan_opt = test_scan.remove_nonoptimized()
scan_opt.compute_energy(param)
self.assertTrue(scan_opt._have_mm_energy)
mm_energy = np.array([
22.66381775, 13.11040092, 3.04552792, 7.83767718, 15.21426107,
7.0116804, 0., 7.00802623, 15.21461956, 7.83696204, 3.04525798,
13.10813678, 22.66375837
])
np.testing.assert_almost_equal(scan_opt.mm_energy._value, mm_energy, 4)
def test_update_param_continuous(self):
""" Tests that update parameter updates the reverse dihedral too in continuous """
param = CharmmParameterSet(get_fn('top_all36_cgenff.rtf'),
get_fn('par_all36_cgenff.prm'))
structure = get_fn('butane.psf')
logfiles = get_fn('MP2_torsion_scan/')
frag = qmdb.parse_psi4_out(logfiles, structure)
frag = frag.remove_nonoptimized()
to_optimize = [('CG331', 'CG321', 'CG321', 'CG331')]
model = TorsionFitModelOMM(param=param,
frags=frag,
param_to_opt=to_optimize,
sample_phase=True,
continuous_phase=True)
torsion = model.parameters_to_optimize[0]
torsion_reverse = tuple(reversed(torsion))
self.assertEqual(param.dihedral_types[torsion],
param.dihedral_types[torsion_reverse])
def test_add_missing_cond(self):
""" Tests that add_missing adds missing terms to parameters_to_optimize """
param = CharmmParameterSet(get_fn('top_all36_cgenff.rtf'),
get_fn('par_all36_cgenff.prm'))
structure = get_fn('butane.psf')
logfiles = get_fn('MP2_torsion_scan/')
frag = qmdb.parse_psi4_out(logfiles, structure)
frag = frag.remove_nonoptimized()
to_optimize = [('CG331', 'CG321', 'CG321', 'HGA2')]
model = TorsionFitModelOMM(param=param,
frags=frag,
param_to_opt=to_optimize,
sample_phase=True,
continuous_phase=True)
par.add_missing(param_list=to_optimize, param=param)
for i in model.frags[0].structure.dihedrals:
key = (i.atom1.type, i.atom2.type, i.atom3.type, i.atom4.type)
key_reverse = tuple(reversed(key))
if key in model.parameters_to_optimize or key_reverse in model.parameters_to_optimize:
self.assert_(len(i.type) == 5)
from torsionfit.hydration_energy import energy
from parmed.charmm import CharmmParameterSet
try:
import cPickle as pickle
except:
import pickle
# Load CHARMM parameters files
params = CharmmParameterSet('../../charmm_ff/top_all36_cgenff.rtf',
'../../charmm_ff/par_all36_cgenff.prm',
'../../charmm_ff/toppar_water_ions.str',
'../pyrrol.str')
db = energy.create_openmm_system('pyrrole', '../structure', params)
db_solv = energy.generate_simulation_data(db, params, n_steps=3000, n_iter=400)
# remove system and context because pickle is giving me problems pickling them
db_new = {}
for key in db_solv['solvated'].keys():
if key == 'system' or key == 'context':
continue
db_new[key] = db_solv['solvated'][key]
pickle.dump(db_new, open('solvated.pickle', 'w'))
pickle.dump(db_solv, open('solvated_test.pickle', 'w'))
def generate_nonbonded_params(self):
"""
Generates non-bonded parameters for energy calculations.
Returns
-------
chg_product : numpy.ndarray
An N_sites x N_particles matrix where N_sites is the number of sites in the water model and N_atoms
is the total number of particles in the system, each entry of the matrix is the product of the charges
q_i*q_j used for the calculation of electrostatic interactions.
acoeff : numpy.ndarray
An N_sites x N_particles matrix where N_sites is the number of sites in the water model and N_atoms
is the total number of particles in the system, each entry of the matrix is the A coefficient in the
AB form of Lennard Jones potential.
bcoeff : numpy.ndarray
An N_sites x N_particles matrix where N_sites is the number of sites in the water model and N_atoms
is the total number of particles in the system, each entry of the matrix is the B coefficient in the
AB form of Lennard Jones potential.
"""
vdw = []
chg = []
if self.supporting_file.endswith(".txt"):
nb_data = np.loadtxt(self.supporting_file)
for c in nb_data[:, 0]:
chg.append(c)
for v in nb_data[:, 1:]:
vdw.append(v)
chg = np.asarray(chg)
elif self.supporting_file.endswith(".txth5"):
nb_data = np.loadtxt(self.supporting_file)
for c in nb_data[:, 0]:
chg.append(c)
for v in nb_data[:, 1:]:
vdw.append(v)
elif self.topology_file.endswith(".psf"):
parmed_topology_object = pmd.load_file(self.topology_file)
param_dir = os.path.abspath(self.supporting_file)
param_files = [
os.path.join(param_dir, f) for f in os.listdir(param_dir)
if os.path.isfile(os.path.join(param_dir, f)) and f.endswith((
".rtf", ".top", ".par", ".prm", ".inp", ".str"))
]
params = CharmmParameterSet(*param_files)
try:
parmed_topology_object.load_parameters(params)
except Exception as e:
print(e)
for at in self.all_atom_ids:
vdw.append([
parmed_topology_object.atoms[at].sigma,
parmed_topology_object.atoms[at].epsilon
])
chg.append(parmed_topology_object.atoms[at].charge)
else:
parmed_topology_object = pmd.load_file(self.supporting_file)
for at in self.all_atom_ids:
vdw.append([
parmed_topology_object.atoms[at].sigma,
parmed_topology_object.atoms[at].epsilon
])
chg.append(parmed_topology_object.atoms[at].charge)
# User provided charges are assumed to be in correct units.
# TODO: Make the units for charges explicit in docstring
if not self.supporting_file.endswith(".txt"):
chg = np.asarray(chg) * 18.2223
vdw = np.asarray(vdw)
water_chg = chg[self.wat_atom_ids[0:self.water_sites]].reshape(
self.water_sites, 1)
chg_product = water_chg * np.tile(chg[self.all_atom_ids],
(self.water_sites, 1))
water_sig = vdw[self.wat_atom_ids[0:self.water_sites],
0].reshape(self.water_sites, 1)
water_eps = vdw[self.wat_atom_ids[0:self.water_sites],
1].reshape(self.water_sites, 1)
mixed_sig, mixed_eps = None, None
if self.comb_rule is None or self.comb_rule == "lorentz-bertholot":
mixed_sig = 0.5 * (water_sig + vdw[self.all_atom_ids, 0])
mixed_eps = np.sqrt(water_eps * vdw[self.all_atom_ids, 1])
if self.comb_rule == "geometric":
mixed_sig = np.sqrt(water_sig * vdw[self.all_atom_ids, 0])
mixed_eps = np.sqrt(water_eps * vdw[self.all_atom_ids, 1])
if mixed_eps is not None and mixed_sig is not None:
acoeff = 4 * mixed_eps * (mixed_sig**12)
bcoeff = 4 * mixed_eps * (mixed_sig**6)
else:
raise Exception("Couldn't assign vdw params")
return chg_product, acoeff, bcoeff
import unittest
from utils import get_fn, TestCaseRelative, mm, app, has_openmm, CPU, Reference
import warnings
# Suppress warning output from bad psf file... sigh.
warnings.filterwarnings('ignore', category=CharmmWarning)
# System
charmm_gas = CharmmPsfFile(get_fn('ala_ala_ala.psf'))
charmm_gas_crds = load_file(get_fn('ala_ala_ala.pdb'))
charmm_nbfix = CharmmPsfFile(get_fn('ala3_solv.psf'))
charmm_nbfix_crds = CharmmCrdFile(get_fn('ala3_solv.crd'))
charmm_nbfix.box = [3.271195e1, 3.299596e1, 3.300715e1, 90, 90, 90]
# Parameter sets
param22 = CharmmParameterSet(get_fn('top_all22_prot.inp'),
get_fn('par_all22_prot.inp'))
param36 = CharmmParameterSet(get_fn('par_all36_prot.prm'),
get_fn('toppar_water_ions.str'))
@unittest.skipUnless(has_openmm, "Cannot test without OpenMM")
class TestCharmmFiles(TestCaseRelative):
def test_gas_energy(self):
""" Compare OpenMM and CHARMM gas phase energies """
parm = charmm_gas
system = parm.createSystem(param22)
self.assertEqual(parm.combining_rule, 'lorentz')
integrator = mm.VerletIntegrator(1.0*u.femtoseconds)
sim = app.Simulation(parm.topology, system, integrator, platform=CPU)
sim.context.setPositions(charmm_gas_crds.positions)
energies = energy_decomposition(parm, sim.context)
from torsionfit.hydration_energy import energy
from parmed.charmm import CharmmParameterSet, CharmmPsfFile
from parmed.topologyobjects import DihedralType
import cPickle as pickle
from torsionfit import sqlite_plus, utils
import simtk.openmm as mm
import simtk.unit as u
import simtk.openmm.app as app
from pymbar import timeseries
import numpy as np
from tqdm import *
param_1 = CharmmParameterSet('../../data/charmm_ff/par_all36_cgenff.prm',
'../../data/charmm_ff/top_all36_prot.rtf',
'../../data/charmm_ff/toppar_water_ions.str')
param_2 = CharmmParameterSet('../../data/charmm_ff/par_all36_cgenff.prm',
'../../data/charmm_ff/top_all36_prot.rtf',
'../../data/charmm_ff/toppar_water_ions.str')
database = energy.create_openmm_system('butane', '../structure/', param_1)
solvated = pickle.load(open('solvated.pickle', 'r'))
vacuum = pickle.load(open('vacuum_db.pickle', 'r'))
database['solvated']['x_n'] = solvated['solvated']['x_n']
database['solvated']['u_n'] = solvated['solvated']['u_n']
database['vacuum']['x_n'] = vacuum['vacuum']['x_n']
database['vacuum']['u_n'] = vacuum['vacuum']['u_n']
# load sampled parameters
db = sqlite_plus.load('../butane_n5_decouple_n.db')
def compare_energies(system_name,
pdb_filename,
psf_filename,
ffxml_filenames,
toppar_filenames,
box_vectors_filename=None,
system_kwargs=None,
tolerance=1e-5,
units=u.kilojoules_per_mole,
write_serialized_xml=False):
"""
Compare energies between (pdb, psf, toppar) loaded via ParmEd and (pdb, ffxml) loaded by OpenMM ForceField
Parameters
----------
system_name : str
Name of the test system
pdb_filename : str
Name of PDB file that should contain CRYST entry and PDB format compliant CONECT records for HETATM residues.
psf_filename : str
CHARMM PSF file
ffxml_filenames : list of str
List of OpenMM ffxml files
toppar_filenames : list of CHARMM toppar filenames to load into CharmmParameterSet
List of CHARMM toppar files
box_vectors_filename : str, optional, default=None
If specified, read box vectors from a file like step2.1_waterbox.prm
system_kwargs : dict, optional, default=None
Keyword arguments to pass to CharmmPsfFile.createSystem() and ForceField.CreateSystem() when constructing System objects for energy comparison
tolerance : float, optional, default=1e-5
Relative energy discrepancy tolerance
units : simtk.unit.Unit
Unit to use for energy comparison
write_serialized_xml : bool, optional, default=False
If True, will write out serialized System XML files for OpenMM systems to aid debugging.
"""
is_periodic = False
if (system_kwargs is not None) and ('nonbondedMethod'
in system_kwargs) and (
system_kwargs['nonbondedMethod']
in [app.CutoffPeriodic, app.PME]):
is_periodic = True
# Load PDB file
pdbfile = app.PDBFile(pdb_filename)
# Read box vectors
if box_vectors_filename:
box_vectors = read_box_vectors(box_vectors_filename)
pdbfile.topology.setPeriodicBoxVectors(box_vectors)
else:
box_vectors = pdbfile.topology.getPeriodicBoxVectors()
# Load CHARMM system through OpenMM
openmm_toppar = app.CharmmParameterSet(*toppar_filenames)
openmm_psf = app.CharmmPsfFile(psf_filename)
# Set box vectors
if is_periodic:
openmm_psf.setBox(box_vectors[0][0], box_vectors[1][1],
box_vectors[2][2])
openmm_system = openmm_psf.createSystem(openmm_toppar, **system_kwargs)
openmm_structure = openmm.load_topology(openmm_psf.topology,
openmm_system,
xyz=pdbfile.positions)
#openmm_energies = openmm.energy_decomposition_system(openmm_structure, openmm_system, nrg=units)
#print('OpenMM CHARMM loader energy components : %s' % str(openmm_energies))
openmm_total_energy = compute_potential(openmm_system,
pdbfile.positions) / units
# Load CHARMM system through ParmEd
parmed_toppar = CharmmParameterSet(*toppar_filenames)
parmed_structure = CharmmPsfFile(psf_filename)
#structure.load_parameters(toppar)
parmed_structure.positions = pdbfile.positions
# Set box vectors
if is_periodic:
parmed_structure.box = (box_vectors[0][0] / u.angstroms,
box_vectors[1][1] / u.angstroms,
box_vectors[2][2] / u.angstroms, 90, 90, 90)
parmed_system = parmed_structure.createSystem(parmed_toppar,
**system_kwargs)
#parmed_energies = openmm.energy_decomposition_system(parmed_structure, parmed_system, nrg=units)
#print('ParmEd CHARMM loader energy components : %s' % str(parmed_energies))
parmed_total_energy = compute_potential(parmed_system,
pdbfile.positions) / units
# Delete H-H bonds from waters and retreive updated topology and positions
modeller = app.Modeller(openmm_psf.topology, pdbfile.positions)
hhbonds = [
b for b in modeller.topology.bonds()
if b[0].element == app.element.hydrogen
and b[1].element == app.element.hydrogen
]
modeller.delete(hhbonds)
ffxml_topology = modeller.topology
# OpenMM system with ffxml
ff = app.ForceField(*ffxml_filenames)
ffxml_system = ff.createSystem(ffxml_topology, **system_kwargs)
ffxml_structure = openmm.load_topology(ffxml_topology,
ffxml_system,
xyz=pdbfile.positions)
#ffxml_energies = openmm.energy_decomposition_system(ffxml_structure, ffxml_system, nrg=units)
#print('ffxml energy components : %s' % str(ffxml_energies))
ffxml_total_energy = compute_potential(ffxml_system,
pdbfile.positions) / units
write_serialized_xml = True # DEBUG
if write_serialized_xml:
print('Writing serialized XML files...')
write_serialized_system(system_name + '.charmm.system.xml',
openmm_system)
write_serialized_system(system_name + '.parmed.system.xml',
parmed_system)
write_serialized_system(system_name + '.openmm.system.xml',
ffxml_system)
print('-' * 100)
print('')
print('OpenMM CHARMM reader total energy: %14.3f' % openmm_total_energy)
print('ParmEd CHARMM reader total energy: %14.3f' % parmed_total_energy)
print('OPENMM ffxml total energy: %14.3f' % ffxml_total_energy)
print('TOTAL ERROR: %14.3f' %
(ffxml_total_energy - openmm_total_energy))
print('')
print('-' * 100)
# TODO : Automate comparison
return
# calc rel energies and assert
rel_energies = []
for i, j in zip(ffxml_energies, parmed_energies):
if i[0] != j[0]:
raise Exception('Mismatch in energy tuples naming.')
if abs(i[1]) > NEARLYZERO:
rel_energies.append((i[0], abs((i[1] - j[1]) / i[1])))
else:
if abs(j[1]) > NEARLYZERO:
raise AssertionError(
'One of the CHARMM %s energies (%s) for %s is zero, '
'while the corresponding OpenMM energy is non-zero' %
(system_name, i[0], ffxml))
rel_energies.append((i[0], 0))
dihedrals_done = False
for i in rel_energies:
if i[0] != 'PeriodicTorsionForce':
if i[1] > tolerance:
raise AssertionError(
'%s energies (%s, %f) outside of allowed tolerance (%f) for %s'
% (system_name, i[0], i[1], tolerance, ffxml))
else:
if not dihedrals_done:
if i[1] > tolerance:
raise AssertionError(
'%s energies (%s, %f) outside of allowed tolerance (%f) for %s'
% (system_name, i[0], i[1], tolerance, ffxml))
dihedrals_done = True
else: #impropers
if i[1] > improper_tolerance:
raise AssertionError(
'%s energies (%s-impropers, %f) outside of allowed tolerance (%f) for %s'
% (system_name, i[0], i[1], improper_tolerance, ffxml))
# logging
if not no_log:
charmm_energies_log = dict()
omm_energies_log = dict()
rel_energies_log = dict()
charmm_energies_log['ffxml_name'] = ffxml
charmm_energies_log['test_system'] = system_name
charmm_energies_log['data_type'] = 'CHARMM'
charmm_energies_log['units'] = units
omm_energies_log['ffxml_name'] = ffxml
omm_energies_log['test_system'] = system_name
omm_energies_log['data_type'] = 'OpenMM'
omm_energies_log['units'] = units
rel_energies_log['ffxml_name'] = ffxml
rel_energies_log['test_system'] = system_name
rel_energies_log['data_type'] = 'abs((CHARMM-OpenMM)/CHARMM)'
dihedrals_done = False
for item in amber_energies:
if item[0] == 'PeriodicTorsionForce' and not dihedrals_done:
charmm_energies_log['PeriodicTorsionForce_dihedrals'] = item[1]
dihedrals_done = True
elif item[0] == 'PeriodicTorsionForce' and dihedrals_done:
charmm_energies_log['PeriodicTorsionForce_impropers'] = item[1]
elif item[0] == 'CMMotionRemover':
continue
else:
charmm_energies_log[item[0]] = item[1]
dihedrals_done = False
for item in omm_energies:
if item[0] == 'PeriodicTorsionForce' and not dihedrals_done:
omm_energies_log['PeriodicTorsionForce_dihedrals'] = item[1]
dihedrals_done = True
elif item[0] == 'PeriodicTorsionForce' and dihedrals_done:
omm_energies_log['PeriodicTorsionForce_impropers'] = item[1]
elif item[0] == 'CMMotionRemover':
continue
else:
omm_energies_log[item[0]] = item[1]
dihedrals_done = False
for item in rel_energies:
if item[0] == 'PeriodicTorsionForce' and not dihedrals_done:
rel_energies_log['PeriodicTorsionForce_dihedrals'] = item[1]
dihedrals_done = True
elif item[0] == 'PeriodicTorsionForce' and dihedrals_done:
rel_energies_log['PeriodicTorsionForce_impropers'] = item[1]
elif item[0] == 'CMMotionRemover':
continue
else:
rel_energies_log[item[0]] = item[1]
logger.log(charmm_energies_log)
logger.log(omm_energies_log)
logger.log(rel_energies_log)
M.xyzs[0] = pos
M.write('constrained.gro')
# Gromacs calculation
GMX_Energy, GMX_Force, Ecomps_GMX = Calculate_GMX('constrained.gro', 'topol.top', 'shot.mdp')
GMX_Force = GMX_Force.reshape(-1,3)
# Print Gromacs energy components
printcool_dictionary(Ecomps_GMX, title="GROMACS energy components")
# Parse the .mdp file to inform ParmEd
defines, sysargs, mdp_opts = interpret_mdp('shot.mdp')
GmxGro = parmed.gromacs.GromacsGroFile.parse('constrained.gro')
# CHARMM calculation
parm = CharmmParameterSet('fb15.prm', 'fb15.rtf')
psf = CharmmPsfFile('sys-full.psf')
crd = CharmmCrdFile('sys-full.crd')
parm.box = GmxGro.box
parm.positions = GmxGro.positions
IPython.embed()
CHARMM_Energy, CHARMM_Force, Ecomps_CHARMM = Calculate_CHARMM(parm, psf, crd, sysargs, defines)
CHARMM_Force = CHARMM_Force.reshape(-1,3)
# Print CHARMM energy components
printcool_dictionary(Ecomps_CHARMM, title="CHARMM energy components")
def compare_ecomps(in1, in2):
groups = [([['Bond'], ['BOND']]),
([['Angle'], ['ANGLE']]),
([['Proper-Dih.', 'Improper-Dih.'], ['DIHED']]),
import parmed as pm
from parmed.charmm import CharmmPsfFile, CharmmCrdFile, CharmmParameterSet
print('Loading CHARMM files...')
params = CharmmParameterSet('toppar/par_all36m_prot.prm', 'toppar/par_all36_lipid.prm')
gram = CharmmPsfFile('../../simulations/themis_data/1jnoetaohh3o2.psf')
for atom in gram.atoms:
print(atom.name, atom.idx, atom.charge, atom.rmin, atom.epsilon)
#!/usr/bin/env python
from __future__ import division, print_function
from collections import defaultdict
import sys
# OpenMM Imports
import simtk.openmm as mm
import simtk.openmm.app as app
import parmed as pmd
# ParmEd Imports
from parmed import load_file, unit as u
from parmed.charmm import CharmmParameterSet
from parmed.openmm import StateDataReporter, energy_decomposition_system
params = CharmmParameterSet('parmed_par_oplsaam.inp')
ala5_gas = load_file('GP.psf')
ala5_crds = load_file('plt.pdb')
# Create the OpenMM system
print('Creating OpenMM System')
system = ala5_gas.createSystem(params,
nonbondedMethod=app.NoCutoff,
nonbondedCutoff=1000.0 * u.angstroms)
# Create the integrator to do Langevin dynamics
integrator = mm.LangevinIntegrator(
300 * u.kelvin, # Temperature of heat bath
1.0 / u.picoseconds, # Friction coefficient
2.0 * u.femtoseconds, # Time step
)
# Define the platform to use; CUDA, OpenCL, CPU, or Reference. Or do not specify
from __future__ import division, print_function
import sys
# OpenMM Imports
import simtk.openmm as mm
import simtk.openmm.app as app
# ParmEd Imports
from parmed import load_file, unit as u
from parmed.charmm import CharmmParameterSet
from parmed.openmm import StateDataReporter
# Load the CHARMM files
print('Loading CHARMM files...')
params = CharmmParameterSet('toppar/par_all36_prot.prm',
'toppar/toppar_water_ions.str')
ala2_solv = load_file('ala2_charmmgui.psf')
ala2_crds = load_file('ala2_charmmgui.crd')
# NOTE NOTE
# The parameter set we used here is the CHARMM 36 force field, but this is
# strictly an example. It is important that you use the most accurate (typically
# most up-to-date) force fields for your own simulation. See the CHARMM
# parameter web page for updates:
# http://mackerell.umaryland.edu/CHARMM_ff_params.html
# END NOTE
# Compute the box dimensions from the coordinates and set the box lengths (only
# orthorhombic boxes are currently supported in OpenMM)
coords = ala2_crds.positions
min_crds = [coords[0][0], coords[0][1], coords[0][2]]
import simtk.openmm as mm
from torsionfit import TorsionScanSet as ScanSet
import torsionfit.TorsionFitModel as Model
from torsionfit import sqlite_plus
from pymc import MCMC
from parmed.charmm import CharmmParameterSet
param_to_opt = [('CG331', 'CG321', 'CG321', 'CG331'),
('HGA3', 'CG331', 'CG321', 'HGA2'),
('HGA3', 'CG331', 'CG321', 'CG321'),
('HGA2', 'CG321', 'CG321', 'HGA2'),
('CG331', 'CG321', 'CG321', 'HGA2')]
param = CharmmParameterSet('../../../../data/charmm_ff/top_all36_cgenff.rtf',
'../../../../data/charmm_ff/par_all36_cgenff.prm')
structure = '../../../structure/butane.psf'
scan = '../../../torsion_scans/MP2_torsion_scan/'
# Print initial guess
print param.dihedral_types[param_to_opt[0]]
# Create a butane scan with torsions on (to compare for difference potential)
butane_scan = ScanSet.parse_psi4_out(scan, structure)
butane_scan.compute_energy(param)
optimized = butane_scan.remove_nonoptimized()
optimized.compute_energy(param)
# Turn off torsion
param.dihedral_types[('CG331', 'CG321', 'CG321', 'CG331')][1].phi_k = 0
param.dihedral_types[('CG331', 'CG321', 'CG321', 'CG331')][0].phi_k = 0
param.dihedral_types[('HGA3', 'CG331', 'CG321', 'HGA2')][0].phi_k = 0
param.dihedral_types[('HGA2', 'CG321', 'CG331', 'HGA3')][0].phi_k = 0
param.dihedral_types[('HGA3', 'CG331', 'CG321', 'CG321')][0].phi_k = 0
from parmed.charmm import CharmmParameterSet
import parmed as pmd
import sys
if __name__ == "__main__":
pfile = sys.argv[1]
sfile = None
if len(sys.argv) > 2:
sfile = sys.argv[2]
if sfile:
psf = pmd.load_file(sfile)
print(len(psf.atoms))
#params = CharmmParameterSet('toph8.rtf', 'param3.prm')
if sfile:
params = CharmmParameterSet.from_structure(psf)
else:
params = CharmmParameterSet()
print(len(psf.atoms))
#params.read_parameter_file('../../../data/par_all27_prot_lipid_chiral.dat')
params.read_parameter_file(pfile)
print(params)
print(params.atom_types)
print('%.4f' % (params.atom_types['CD'].epsilon))
print('%.4f' % (params.atom_types['CD'].rmin))
print('%.4f' % (params.atom_types['NH3'].epsilon))
print('%.4f' % (params.atom_types['NH3'].rmin))
#print(params.bond_types)
#print(params.angle_types)
#print(params.dihedral_types)
def __init__(self, molecule, param_filepath):
super(StructurePredictor, self).__init__()
self.params = CharmmParameterSet(param_filepath)
self.m = molecule
from torsionfit.backends import sqlite_plus
import torsionfit.parameters as par
from pymc import MCMC
import pymc
from parmed.charmm import CharmmParameterSet
import unittest
try:
from simtk.openmm import app
import simtk.openmm as mm
HAVE_OPENMM = True
except ImportError:
HAVE_OPENMM = False
param = CharmmParameterSet(get_fn('top_all36_cgenff.rtf'),
get_fn('par_all36_cgenff.prm'))
structure = get_fn('butane.psf')
logfiles = get_fn('MP2_torsion_scan/')
frag = qmdb.parse_psi4_out(logfiles, structure)
frag = frag.remove_nonoptimized()
to_optimize = [('CG331', 'CG321', 'CG321', 'CG331')]
model_omm = TorsionFitModelOMM(param=param,
frags=frag,
param_to_opt=to_optimize,
init_random=False)
class TestFitModel(unittest.TestCase):
""" Tests pymc model"""
def test_pymc_model(self):
""" Tests sampler """
from torsionfit import sqlite_plus
from pymc import MCMC
from parmed.charmm import CharmmParameterSet
import glob
from pymc import MCMC
structure = 'pyrrol.psf'
scan = glob.glob('torsion-scan/*.log')
pyrrol_scan = ScanSet.parse_gauss(scan, structure)
pyrrol_opt = pyrrol_scan.extract_geom_opt()
# set up torsionfit model
param_to_optimize = [
('CG331', 'CG321', 'CG321', 'NG3C51'),
('CG321', 'CG321', 'NG3C51', 'CG2R51'),
('CG321', 'CG321', 'NG3C51', 'CG251O'),
('CG2D2', 'CG251O', 'NG3C51', 'CG321'),
]
param = CharmmParameterSet('../charmm_ff/top_all36_cgenff.rtf',
'../charmm_ff/par_all36_cgenff.prm', 'pyrrol.str')
model = Model.TorsionFitModelEliminatePhase(param,
pyrrol_opt,
decouple_n=True,
sample_n5=True,
param_to_opt=param_to_optimize)
db = sqlite_plus.load('pyrrol_4.db')
sampler = MCMC(model.pymc_parameters, db=db)
sampler.restore_sampler_state()
sampler.sample(100000)
def convert_yaml(yaml_filename, ffxml_dir):
# Read YAML
data = yaml.safe_load(open(yaml_filename, 'r'))
source_pack = data[0]['sourcePackage']
source_pack_ver = data[0]['sourcePackageVersion']
for entry in data[1:]:
ffxml_filename = os.path.join(ffxml_dir, entry['Destination'])
print('Generating %s' % ffxml_filename)
charmm_references = entry['References']
source_files = entry['Source']
# files that should be excluded from conversion.
exclude_files = set()
if ('exclude' in source_files) and (source_files['exclude']
is not None):
exclude_files = set(source_files['exclude'])
# charmm36 main top and par files
charmm_files = list()
if ('include' in source_files) and (source_files['include']
is not None):
charmm_files = source_files['include']
# add stream files
if ('stream' in source_files) and (source_files['stream'] is not None):
for files in source_files['stream']:
charmm_files.extend(glob.glob(files))
# compile residue template names to exclude
exclude_residues = list()
if 'exclude_residues' in source_files:
for resname in source_files['exclude_residues']:
exclude_residues.append(resname)
# exclude files from conversion, maintaining deterministic order
for filename in exclude_files:
try:
charmm_files.remove(filename)
except Exception as e:
print(
'Specified excluded file "%s" does not appear in list of files'
% filename)
provenance = OrderedDict()
source = provenance['Source'] = []
for fi in charmm_files:
source.append(OrderedDict())
source[-1]['Source'] = fi
md5 = hashlib.md5()
with open(fi, 'rb') as f:
md5.update(f.read())
md5 = md5.hexdigest()
source[-1]['md5hash'] = md5
source[-1]['sourcePackage'] = source_pack
source[-1]['sourcePackageVersion'] = source_pack_ver
references = provenance['Reference'] = []
for ff in charmm_references:
for cite in charmm_references[ff]:
references.append(OrderedDict())
if type(cite) is dict:
for key in cite.keys():
citation = cite[key]
references[-1]['Reference'] = citation
references[-1]['forcefield'] = ff
references[-1]['type'] = key
else:
citation = cite
references[-1]['Reference'] = citation
references[-1]['forcefield'] = ff
#generate recommended combination for charmm36
if verbose: print('Loading CHARMM parameter sets %s...' % charmm_files)
params = CharmmParameterSet(*charmm_files)
if len(exclude_residues) > 0:
if verbose: print('Excluding residues: %s' % exclude_residues)
for resname in exclude_residues:
del params.residues[resname]
if verbose: print('Converting parameters to OpenMM...')
params_omm = openmm.OpenMMParameterSet.from_parameterset(
params, unique_atom_types=True)
# Set override level
if 'Override' in entry:
override_level = int(entry['Override'])
if verbose:
print('Setting residues and patches to override level %d...' %
override_level)
for name, residue in params_omm.residues.items():
residue.override_level = override_level
for name, patch in params_omm.patches.items():
patch.override_level = override_level
if verbose:
print(
'Writing parameter set and compatible patches. This may take several minutes...'
)
params_omm.write(ffxml_filename,
provenance=provenance,
charmm_imp=True,
separate_ljforce=True)
# Try reading the forcefield back in to make sure it is valid
if verbose: print('Verifying ffxml file integrity...')
if 'TestInclude' in entry:
ffxml_include = entry['TestInclude']
forcefield = app.ForceField(ffxml_filename, *ffxml_include)
else:
forcefield = app.ForceField(ffxml_filename)
if 'Test' in entry:
for filename in entry['Test']:
if verbose: print('Testing with %s ...' % filename)
pdbfile = app.PDBFile(filename)
system = forcefield.createSystem(pdbfile.topology)
if verbose: print('Verified.')
from __future__ import division, print_function
import sys
# OpenMM Imports
import simtk.openmm as mm
import simtk.openmm.app as app
# ParmEd Imports
from parmed.charmm import CharmmPsfFile, CharmmCrdFile, CharmmParameterSet
from parmed.openmm import StateDataReporter
from parmed import unit as u
# Load the CHARMM files
print('Loading CHARMM files...')
params = CharmmParameterSet('BNZ_2_PRD.prm')
ala5_gas = CharmmPsfFile('zero.psf')
ala5_crds = app.PDBFile('A2B_gas.pdb')
type_map = {
'O': 'OT',
'OH2': 'OT',
'H1': 'HT',
'H2': 'HT',
'LP': 'LP',
'OM': 'LP',
'LP1': 'LP',
'LP2': 'LP',
}
for nsites in [3, 4, 5]:
pdb_filename = 'waterbox-{}-site.pdb'.format(nsites)
psf_filename = 'waterbox-{}-site.psf'.format(nsites)
str_filename = 'toppar_tip{}p.str'.format(nsites)
pdb = pmd.load_file(pdb_filename)
for atom in pdb.atoms:
atom.type = type_map[atom.name]
# Delete bonds to lone pairs
indices_to_delete = list()
for (index, bond) in enumerate(list(pdb.bonds)):
if (bond.atom1.type == 'LP') or (bond.atom2.type == 'LP'):
indices_to_delete.append(index)
for index in indices_to_delete[-1:0:-1]:
pdb.bonds[index].delete()
del pdb.bonds[index]
params = CharmmParameterSet(str_filename)
PSFFile.write(pdb, psf_filename)
from __future__ import division, print_function
import sys
# OpenMM Imports
import simtk.openmm as mm
import simtk.openmm.app as app
# ParmEd Imports
from parmed import load_file, unit as u
from parmed.charmm import CharmmParameterSet
from parmed.openmm import StateDataReporter
# Load the CHARMM files
print('Loading CHARMM files...')
params = CharmmParameterSet('toppar/par_all36_prot.prm')
ala5_gas = load_file('ala5_autopsf.psf')
ala5_crds = load_file('ala5_autopsf.pdb')
# NOTE NOTE
# The parameter set we used here is the CHARMM 36 force field, but this is
# strictly an example. It is important that you use the most accurate (typically
# most up-to-date) force fields for your own simulation. See the CHARMM
# parameter web page for updates:
# http://mackerell.umaryland.edu/CHARMM_ff_params.html
# END NOTE
# Create the OpenMM system
print('Creating OpenMM System')
system = ala5_gas.createSystem(
params,
#!/usr/bin/env python
from collections import defaultdict
import sys
# OpenMM Imports
import simtk.openmm as mm
from simtk.openmm import KcalPerKJ
import simtk.openmm.app as app
import parmed as pmd
# ParmEd Imports
from parmed import load_file, unit as u
from parmed.charmm import CharmmParameterSet
from parmed.openmm import StateDataReporter, energy_decomposition_system
params = CharmmParameterSet('QUBE_FF_openmm.par')
ala5_gas = load_file('new_ionized.psf')
ala5_crds = load_file('ionized.pdb')
system = ala5_gas.createSystem(params,
nonbondedMethod=app.NoCutoff,
nonbondedCutoff=500.0 * u.angstroms,
switchDistance=496.0 * u.angstroms)
#serializing the system
from simtk.openmm import XmlSerializer
serialized_system = XmlSerializer.serialize(system)
outfile = open('serialized_system.xml', 'w')
outfile.write(serialized_system)
outfile.close()
# Create the integrator to do Langevin dynamics