def addRDF(rdf, pdbfile, xscfile=None):
"""Add to the RDF 'rdf' the distances calculated using the coordinates
from the PDB file 'pdbfile', using the xscfile 'xscfile' to get the
dimensions of the periodic box. If 'xscfile' is None, then
no periodic boundary conditions are used."""
#first get the space in which to calculate intermolecular distances
space = Cartesian()
if xscfile:
lines = open(xscfile,"r").readlines()
words = lines[0].split()
mincoords = Vector( float(words[0]), float(words[1]), float(words[2]) )
maxcoords = Vector( float(words[3]), float(words[4]), float(words[5]) )
space = PeriodicBox(mincoords, maxcoords)
#now load all of the molecules
mols = PDB().read(pdbfile)
#create a system to hold the molecules, and add them
system = System()
system.add( MoleculeGroup("molecules", mols) )
#give the space to the system
system.add( InterCLJFF() ) # bug! need to add InterCLJFF so
# that the system has a space property. This
# is fixed in new version of Sire, but is broken
# in your version
system.setProperty("space", space)
#add the RDF - this calculates the RDF for this PDB file and adds it to 'rdf'
rdf.monitor(system)
def buildSystem(forcefields):
system = System()
for forcefield in forcefields:
system.add(forcefield)
system.setProperty("space", space)
system.setProperty("switchingFunction", HarmonicSwitchingFunction(8*angstrom, 7.5*angstrom))
system.setProperty("shiftDelta", VariantProperty(2.0))
system.setProperty("coulombPower", VariantProperty(0))
return system
def createSystem(molecules):
moleculeNumbers = molecules.molNums()
moleculeList = []
for moleculeNumber in moleculeNumbers:
molecule = molecules.molecule(moleculeNumber).molecule()
moleculeList.append(molecule)
all = MoleculeGroup("all")
for molecule in moleculeList[0:]:
all.add(molecule)
gridwater = MoleculeGroup("gridwater")
otherwater = MoleculeGroup("otherwater")
solutes = MoleculeGroup("solutes")
# Add these groups to the System
system = System()
system.add(all)
system.add(gridwater)
system.add(otherwater)
system.add(solutes)
return system
def createSystem(molecules):
# print("Applying flexibility and zmatrix templates...")
print("Creating the system...")
moleculeNumbers = molecules.molNums()
moleculeList = []
for moleculeNumber in moleculeNumbers:
molecule = molecules.molecule(moleculeNumber).molecule()
moleculeList.append(molecule)
molecules = MoleculeGroup("molecules")
ions = MoleculeGroup("ions")
for molecule in moleculeList:
natoms = molecule.nAtoms()
if natoms == 1:
ions.add(molecule)
else:
molecules.add(molecule)
all = MoleculeGroup("all")
all.add(molecules)
all.add(ions)
# Add these groups to the System
system = System()
system.add(all)
system.add(molecules)
system.add(ions)
return system
def createSystem(molecules):
#print("Applying flexibility and zmatrix templates...")
print("Creating the system...")
moleculeNumbers = molecules.molNums()
moleculeList = []
for moleculeNumber in moleculeNumbers:
molecule = molecules.molecule(moleculeNumber)[0].molecule()
moleculeList.append(molecule)
molecules = MoleculeGroup("molecules")
ions = MoleculeGroup("ions")
for molecule in moleculeList:
natoms = molecule.nAtoms()
if natoms == 1:
ions.add(molecule)
else:
molecules.add(molecule)
all = MoleculeGroup("all")
all.add(molecules)
all.add(ions)
# Add these groups to the System
system = System()
system.add(all)
system.add(molecules)
system.add(ions)
return system
def _createSystem(molecules):
moleculeNumbers = molecules.molNums()
moleculeList = []
for moleculeNumber in moleculeNumbers:
molecule = molecules.molecule(moleculeNumber)[0].molecule()
moleculeList.append(molecule)
molecules = MoleculeGroup("molecules")
ions = MoleculeGroup("ions")
for molecule in moleculeList:
natoms = molecule.nAtoms()
if natoms == 1:
ions.add(molecule)
else:
molecules.add(molecule)
all = MoleculeGroup("all")
all.add(molecules)
all.add(ions)
# Add these groups to the System
system = System()
system.add(all)
system.add(molecules)
system.add(ions)
return system
def test_fixed_center(verbose = False):
ligand = Sire.Stream.load("../io/osel.s3")
ligand = ligand.edit().setProperty("center", wrap(ligand.evaluate().center())).commit()
old_center = ligand.property("center")
intraff = InternalFF("intraff")
intraff.add(ligand)
intraclj = IntraCLJFF("intraclj")
intraclj.add(ligand)
system = System()
system.add(intraff)
system.add(intraclj)
mols = MoleculeGroup("mols")
mols.add(ligand)
system.add(mols)
intramove = InternalMove(mols)
rbmove = RigidBodyMC(mols)
rbmove.setMaximumTranslation(0*angstrom)
moves = WeightedMoves()
moves.add(intramove, 1)
moves.add(rbmove, 1)
for i in range(0,10):
system = moves.move(system, 25, False)
if verbose:
print("Completed 25 moves...")
ligand = system[ligand.number()].molecule()
new_center = ligand.property("center")
if verbose:
print("Old center = %s" % old_center)
print("New center = %s" % new_center)
assert_almost_equal( old_center.x(), new_center.x(), 1 )
assert_almost_equal( old_center.y(), new_center.y(), 1 )
assert_almost_equal( old_center.z(), new_center.z(), 1 )
field_clj = IntraCLJFF("field_clj")
field_clj.setUseReactionField(True)
field_clj.setReactionFieldDielectric(78.3)
forcefields = [group_clj, shift_clj, field_clj]
group_coul = group_clj.components().coulomb()
shift_coul = shift_clj.components().coulomb()
field_coul = field_clj.components().coulomb()
system = System()
for forcefield in forcefields:
forcefield.add(protein)
system.add(forcefield)
def printEnergies(nrgs):
keys = list(nrgs.keys())
keys.sort()
for key in keys:
print("%25s : %12.8f" % (key, nrgs[key]))
system.setProperty("switchingFunction",
HarmonicSwitchingFunction(10 * angstrom, 9.5 * angstrom))
printEnergies(system.energies())
from Sire.System import *
from Sire.IO import *
from Sire.FF import *
from Sire.Maths import *
from Sire.Mol import *
from Sire.Vol import *
mols = PDB().read("test/io/water.pdb")
solvent = MoleculeGroup("solvent", mols)
system = System()
system.add(solvent)
system.setProperty("space", Cartesian())
points = [
Vector(10, 10, 10),
solvent.moleculeAt(0).atom(AtomName("O00")),
Vector(0, 0, 0),
Vector(5, 5, 5)
]
print(solvent.moleculeAt(0).molecule().number())
idassigner = IDAssigner(points, solvent)
points = idassigner.points()
idassigner.update(system)
mols = idassigner.identifiedMolecules()
cljff.add(mol)
ms = t.elapsed()
print("Parameterised all of the water molecules (in %d ms)!" % ms)
system = System()
rdf = RDFMonitor( 0*angstrom, 10*angstrom, 0.05*angstrom )
rdf.add( MolIdx(0) + AtomName("O00"), AtomName("O00") )
rdf2 = RDFMonitor( 0*angstrom, 10*angstrom, 0.05*angstrom )
rdf2.add( MolIdx(0) + AtomName("O00"), AtomName("H01") )
rdf2.add( MolIdx(0) + AtomName("O00"), AtomName("H02") )
system.add(cljff)
system.add("O-O RDF", rdf)
system.add("O-H RDF", rdf2)
t.start()
system.collectStats()
ms = t.elapsed()
print("Collecting stats took %d ms" % ms)
rdf = system.monitor( MonitorName("O-O RDF") )
print("\nO-O RDF")
for i in range(0,rdf.nBins()):
cljff.add(mol)
for i in range(1, mols.nMolecules()):
mol = mols.moleculeAt(i).molecule()
mol = mol.edit().rename("T4P") \
.setProperty("charge", charges) \
.setProperty("LJ", ljs) \
.commit()
cljff.add(mol)
system = System()
system.add(cljff)
lam = Symbol("lambda")
system.setComponent( lam, 0.2 )
system.setComponent( system.totalComponent(), lam * cljff.components().total() )
mc = RigidBodyMC(cljff.group(MGIdx(0)))
moves = SameMoves(mc)
def test_stream(verbose=False):
if verbose:
print("saving system...")
data = Sire.Stream.save(system)
salt.add(cl)
add_cl = False
else:
na = na.edit().renumber() \
.setProperty("coordinates", AtomCoords([coords]) ) \
.commit()
salt.add(na)
add_cl = True
cljff = InterCLJFF("salt-salt")
cljff.add(salt)
system = System()
system.add(salt)
system.add(cljff)
def test_conservation(verbose=False):
mdmove = MolecularDynamics(salt)
mdmove.setTimeStep(1 * femtosecond)
old_nrg = None
for i in range(0, 25):
if verbose:
print("move %d" % (i + 1))
cljff.setSwitchingFunction(switchfunc)
# We now need to add all of the water molecules to this forcefield,
# telling it to get the charges from the "charge" property, and the
# LJ parameters from the "LJ" property
cljff.add(waters, {"charge": "charge", "LJ": "LJ"})
# Note that "charge" and "LJ" are the default names, so we could
# have just written 'cljff.add(waters)'
# Now create a simulation System - this holds all of the molecules,
# forcefields and monitors
system = System()
# Add the CLJ forcefield to the system
system.add(cljff)
# Add the molecule group containing the waters to the system - we will give
# this molecule group the name 'waters' so that we can extract it from
# the system at a later point in the script
waters.setName("waters")
system.add(waters)
# Add a constraint that waters are mapped back into the periodic box
system.add(SpaceWrapper(Vector(0, 0, 0), waters))
print "Calculating the starting energy... (should be -16364.5 kcal mol-1)"
print "...Initial energy = %s" % system.energy()
# Now create the rigid body move (RigidBodyMC, from Sire.Move) that act on the waters
rbmc = RigidBodyMC(waters)
from Sire.Base import *
from Sire.FF import *
sys = System()
from Sire.Maths import *
box0 = PeriodicBox( Vector(10.0,10.0,10.0) )
box1 = PeriodicBox( Vector(20.0,20.0,20.0) )
print(box0)
print(box0.volume())
print(box1.volume())
from Sire.MM import *
sys.add( InterCLJFF("cljff") )
print(sys)
print(sys.property("space"))
print(sys.userProperties().propertyKeys())
print(sys.builtinProperties().propertyKeys())
sys.setProperty( "space0", LinkToProperty("space", FFIdx(0)) )
print(sys.property("space0"))
sys.setProperty("space0", box0)
print(sys.property("space"))
sys.setProperty("space1", box1)
hcl2_group = MoleculeGroup("HCl2", hcl2)
cff = InterCoulombFF("CoulombFF")
cff.add(hcl)
cff.add(hcl2)
print("Energy is %s : Should be about -10.9634 kcal mol-1" % cff.energy())
pottable = PotentialTable(hcl2_group)
cff.potential(pottable)
print("Potential is %s : Should be about [ -47.342 kcal mol-1, -15.380 kcal mol-1 ]" % \
(str(pottable.getTable(hcl2.number()).toVector())))
pol = PolariseCharges(hcl2_group)
system = System()
system.add(cff)
system.add(hcl2_group)
system.add(pol.selfEnergyFF())
system.add(pol)
system.applyConstraints()
hcl2 = system[hcl2.number()].molecule()
print(system.energies())
print(hcl2.property("induced_charge"))
mol = mol.edit().rename("SB2").commit()
mol = protoms.parameterise(mol, ProtoMS.SOLUTE)
perturbations = mol.property("perturbations")
print(perturbations)
print(perturbations.requiredSymbols())
print(perturbations.requiredProperties())
lam = perturbations.symbols().Lambda()
system = System()
solute = MoleculeGroup("solute", mol)
system.add(solute)
system.setConstant(lam, 0.0)
system.add( PerturbationConstraint(solute) )
print(system.constraintsSatisfied())
for i in range(0,101,10):
system.setConstant(lam, 0.01 * i)
PDB().write(system.molecules(), "test_%003d.pdb" % i)
def _pvt_calculateEnergy(lamval, verbose):
cljff01 = InterGroupCLJFF("cljff01")
cljff02 = InterGroupCLJFF("cljff02")
cljff01.add( water0, MGIdx(0) )
cljff01.add( water1, MGIdx(1) )
cljff02.add( water0, MGIdx(0) )
cljff02.add( water2, MGIdx(1) )
soft_cljff01 = InterGroupSoftCLJFF("soft_cljff01")
soft_cljff02 = InterGroupSoftCLJFF("soft_cljff02")
soft_cljff01.add( water0, MGIdx(0) )
soft_cljff01.add( water1, MGIdx(1) )
soft_cljff02.add( water0, MGIdx(0) )
soft_cljff02.add( water2, MGIdx(1) )
ref = MoleculeGroup("ref", water0)
group_a = MoleculeGroup("group_a", water1)
group_b = MoleculeGroup("group_b", water2)
dlam = 0.001
lamval_f = lamval + dlam
lam = Symbol("lambda")
lam_f = Symbol("lambda_f")
soft_nrg = (1-lam) * soft_cljff01.components().total(0) + lam * soft_cljff02.components().total(0)
soft_nrg_f = (1-lam_f) * soft_cljff01.components().total(1) + lam_f * soft_cljff02.components().total(1)
de_soft = soft_nrg_f - soft_nrg
nrg = ((1-lam) * cljff01.components().total()) + (lam * cljff02.components().total())
nrg_f = ((1-lam_f) * cljff01.components().total()) + (lam_f * cljff02.components().total())
de = nrg_f - nrg
soft_cljff01.setProperty("alpha0", VariantProperty(lamval))
soft_cljff02.setProperty("alpha0", VariantProperty(1-lamval))
soft_cljff01.setProperty("alpha1", VariantProperty(lamval_f))
soft_cljff02.setProperty("alpha1", VariantProperty(1-lamval_f))
soft_cljff01.setProperty("coulombPower", VariantProperty(0))
soft_cljff01.setProperty("shiftDelta", VariantProperty(1.1))
soft_cljff02.setProperty("coulombPower", VariantProperty(0))
soft_cljff02.setProperty("shiftDelta", VariantProperty(1.1))
sys = System()
sys.add(cljff01)
sys.add(cljff02)
sys.add(soft_cljff01)
sys.add(soft_cljff02)
sys.add(ref)
sys.add(group_a)
sys.add(group_b)
sys.setComponent(lam, lamval)
sys.setComponent(lam_f, lamval_f)
sys.setComponent(sys.totalComponent(), nrg)
sys.setComponent(Symbol("E_{total_f}"), nrg_f)
sys.setComponent(Symbol("dE"), de)
sys.setComponent(Symbol("E_soft_{total}"), soft_nrg)
sys.setComponent(Symbol("E_soft_{total_f}"), soft_nrg_f)
sys.setComponent(Symbol("dE_soft"), de_soft)
nrgmon = FreeEnergyMonitor(ref, group_a, group_b)
soft_nrgmon = FreeEnergyMonitor(ref, group_a, group_b)
soft_nrgmon.setCoulombPower(0)
soft_nrgmon.setShiftDelta(1.1)
sys.add( "nrgmon", nrgmon )
sys.add( "soft_nrgmon", soft_nrgmon)
sys.collectStats()
nrgmon = sys[ MonitorName("nrgmon") ]
dg = nrgmon.freeEnergies()[0].average()
soft_nrgmon = sys[ MonitorName("soft_nrgmon") ]
soft_dg = soft_nrgmon.freeEnergies()[0].average()
sys_dg = sys.energy(Symbol("dE")).value()
sys_soft_dg = sys.energy(Symbol("dE_soft")).value()
if verbose:
print("%s : %s versus %s (should be equal)" % (lamval,dg,sys_dg))
print("%s : %s versus %s (should be equal)" % (lamval,soft_dg,sys_soft_dg))
assert_almost_equal(dg, sys_dg, 5)
assert_almost_equal(soft_dg, sys_soft_dg, 5)
mols.add(krypton)
# create the periodic box space for the atoms
box = PeriodicBox( Vector(box_size[0].value(),
box_size[1].value(),
box_size[2].value()) )
# create a forcefield to calculate the intermolecular coulomb and LJ (CLJ)
# energy between all krypton atoms
interff = InterCLJFF("CLJ")
interff.setProperty("space", box)
interff.add(mols)
# create a simulation system to hold the forcefield and atoms
system = System()
system.add(interff)
system.add(mols)
system.setProperty("space", box)
# add a wrapper that wraps the atoms back into the box
system.add( SpaceWrapper( Vector(0), mols ) )
# create rigid body translation moves for the atoms
rb_moves = RigidBodyMC(mols)
rb_moves.setMaximumTranslation(max_translate)
rb_moves.setTemperature(temperature)
# create volume moves to change the box size
vol_moves = VolumeMove(mols)
vol_moves.setMaximumVolumeChange( mols.nMolecules() * 0.1 * angstrom3 )
vol_moves.setTemperature(temperature)
.setProperty("LJ", lj) \
.molecule().commit()
solvent_charges = mol.property("charge")
solvent_ljs = mol.property("LJ")
solvent = MoleculeGroup("solvent", mols)
for molnum in mols.molNums():
mol = mols[molnum].molecule().edit().setProperty("charge", solvent_charges) \
.setProperty("LJ", solvent_ljs).commit()
solvent.update(mol)
system = System()
system.add(solute)
system.add(solvent)
solvent_cljff = InterCLJFF("solvent_cljff")
solvent_cljff.add(solvent)
solute_solvent_cljff = InterGroupCLJFF("solute_solvent_cljff")
solute_solvent_cljff.add(solute, MGIdx(0))
solute_solvent_cljff.add(solvent, MGIdx(1))
system.add(solvent_cljff)
system.add(solute_solvent_cljff)
system.setProperty(
"space",
PeriodicBox(Vector(-18.3854, -18.66855, -18.4445),
Vector(18.3854, 18.66855, 18.4445)))
radius = 10*angstrom
waters = MoleculeGroup("waters")
for molnum in mols.molNums():
mol = mols[molnum].molecule()
if mol.evaluate().center().length() < radius.value():
waters.add(mol)
ff = InterCLJFF("cljff")
ff.add(waters)
system = System()
system.add(ff)
system.add(waters)
def test_central(verbose=False):
testsys = System(system)
moves = RigidBodyMC(waters)
moves.setReflectionSphere(Vector(0), radius)
if verbose:
print("Performing 5000 moves 10 times...")
PDB().write(testsys.molecules(), "test_central0000.pdb")
for i in range(1,11):
moves.move(testsys, 5000, False)
stream.write("%8.3f %8.3f\n" % (bin.middle(), bin.value() / count))
# Load and parameterise
solute = PDB().readMolecule(solute_file)
solute = solute.edit().rename(solute_name).commit()
protoms = createProtoMS()
protoms.addParameterFile(solute_params)
solute = protoms.parameterise(solute, ProtoMS.SOLUTE)
# Putting the solute in the system
system = System()
solutemolecules = MoleculeGroup("solute", solute)
system.add(solutemolecules)
# Setting a forcefield
solute_intraff = InternalFF("solute_intraff")
solute_intraff.add(solutemolecules)
solute_intraclj = IntraCLJFF("solute_intraclj")
solute_intraclj.add(solute)
forcefields = [solute_intraff, solute_intraclj]
for forcefield in forcefields:
system.add(forcefield)
# Setup the Moves
solute_intra_moves = ZMatMove(solutemolecules)
oscillator = oscillator.edit().rename("harm1t2").commit()
protoms = ProtoMS("%s/protoms2" % protodir)
protoms.addParameterFile("test/io/oscillators.ff")
oscillator = protoms.parameterise(oscillator, ProtoMS.SOLUTE)
print("...parameterisation complete!")
internalff = InternalFF("InternalFF")
internalff.add(oscillator)
system = System()
system.add(internalff)
lam = Symbol("lambda")
system.setComponent(lam, 0.01)
system.setComponent(system.totalComponent(),
lam * internalff.components().total())
system.add("average energy", MonitorComponent(system.totalComponent()))
lambda_values = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
replicas = Replicas(system, len(lambda_values))
replicas.setLambdaComponent(lam)
atom_cljff.setUseAtomisticCutoff(True)
group_coul = group_cljff.components().coulomb()
shift_coul = shift_cljff.components().coulomb()
field_coul = field_cljff.components().coulomb()
atom_coul = atom_cljff.components().coulomb()
forcefields = [ group_cljff, shift_cljff, field_cljff, atom_cljff ]
switchfunc = HarmonicSwitchingFunction(10*angstrom, 9.5*angstrom)
system = System()
for forcefield in forcefields:
forcefield.add(waters)
system.add(forcefield)
def printEnergies(nrgs):
keys = list(nrgs.keys())
keys.sort()
for key in keys:
print("%25s : %12.8f" % (key, nrgs[key]))
system.setProperty("space", space)
system.setProperty("switchingFunction", switchfunc)
printEnergies(system.energies())
print("\nEnergy with respect to cutoff length\n")
print(" Distance Group Shifted ReactionField Atomistic")
def loadQMMMSystem():
"""This function is called to set up the system. It sets everything
up, then returns a System object that holds the configured system"""
print("Loading the system...")
t = QTime()
if os.path.exists(s3file.val):
print("Loading existing s3 file %s..." % s3file.val)
loadsys = Sire.Stream.load(s3file.val)
else:
print("Loading from Amber files %s / %s..." %
(topfile.val, crdfile.val))
# Add the name of the ligand to the list of solute molecules
sys_scheme = NamingScheme()
sys_scheme.addSoluteResidueName(ligand_name.val)
# Load up the system. This will automatically find the protein, solute, water, solvent
# and ion molecules and assign them to different groups
loadsys = createSystem(topfile.val, crdfile.val, sys_scheme)
ligand_mol = findMolecule(loadsys, ligand_name.val)
if ligand_mol is None:
print(
"Cannot find the ligand (%s) in the set of loaded molecules!" %
ligand_name.val)
sys.exit(-1)
# Center the system with the ligand at (0,0,0)
loadsys = centerSystem(loadsys, ligand_mol)
ligand_mol = loadsys[ligand_mol.number()][0].molecule()
if reflection_radius.val is None:
loadsys = addFlexibility(loadsys, naming_scheme=sys_scheme)
else:
loadsys = addFlexibility(loadsys,
Vector(0),
reflection_radius.val,
naming_scheme=sys_scheme)
Sire.Stream.save(loadsys, s3file.val)
ligand_mol = findMolecule(loadsys, ligand_name.val)
if ligand_mol is None:
print("Cannot find the ligand (%s) in the set of loaded molecules!" %
ligand_name.val)
sys.exit(-1)
# Now build the QM/MM system
system = System("QMMM system")
if loadsys.containsProperty("reflection center"):
reflect_center = loadsys.property("reflection center").toVector()[0]
reflect_radius = float(
str(loadsys.property("reflection sphere radius")))
system.setProperty("reflection center",
AtomCoords(CoordGroup(1, reflect_center)))
system.setProperty("reflection sphere radius",
VariantProperty(reflect_radius))
space = Cartesian()
else:
space = loadsys.property("space")
if loadsys.containsProperty("average solute translation delta"):
system.setProperty("average solute translation delta", \
loadsys.property("average solute translation delta"))
if loadsys.containsProperty("average solute rotation delta"):
system.setProperty("average solute rotation delta", \
loadsys.property("average solute rotation delta"))
# create a molecule group to hold all molecules
all_group = MoleculeGroup("all")
# create a molecule group for the ligand
ligand_group = MoleculeGroup("ligand")
ligand_group.add(ligand_mol)
all_group.add(ligand_mol)
groups = []
groups.append(ligand_group)
# pull out the groups that we want from the two systems
# create a group to hold all of the fixed molecules in the bound leg
fixed_group = MoleculeGroup("fixed_molecules")
if MGName("fixed_molecules") in loadsys.mgNames():
fixed_group.add(loadsys[MGName("fixed_molecules")])
if save_pdb.val:
# write a PDB of the fixed atoms in the bound and free legs
if not os.path.exists(outdir.val):
os.makedirs(outdir.val)
PDB().write(fixed_group, "%s/fixed.pdb" % outdir.val)
# create a group to hold all of the mobile solute molecules
mobile_solutes_group = MoleculeGroup("mobile_solutes")
if MGName("mobile_solutes") in loadsys.mgNames():
mobile_solutes_group.add(loadsys[MGName("mobile_solutes")])
mobile_solutes_group.remove(ligand_mol)
if mobile_solutes_group.nMolecules() > 0:
all_group.add(mobile_solutes_group)
groups.append(mobile_solutes_group)
# create a group to hold all of the mobile solvent molecules
mobile_solvents_group = MoleculeGroup("mobile_solvents")
if MGName("mobile_solvents") in loadsys.mgNames():
mols = loadsys[MGName("mobile_solvents")]
for molnum in mols.molNums():
solvent_mol = mols[molnum][0].molecule()
mobile_solvents_group.add(solvent_mol)
all_group.add(mobile_solvents_group)
print("The number of mobile solvent molecules is %d." %
mobile_solvents_group.nMolecules())
groups.append(mobile_solvents_group)
# create the groups to hold all of the protein molecules. We will use "extract" to
# pull out only those protein atoms that are in the mobile region
protein_intra_group = MoleculeGroup("protein_intra_group")
mobile_proteins_group = MoleculeGroup("proteins")
mobile_protein_sidechains_group = MoleculeGroup("mobile_sidechains")
mobile_protein_backbones_group = MoleculeGroup("mobile_backbones")
if MGName("protein_sidechains") in loadsys.mgNames() or \
MGName("protein_backbones") in loadsys.mgNames():
all_proteins = Molecules()
try:
protein_sidechains = loadsys[MGName("protein_sidechains")]
all_proteins.add(protein_sidechains.molecules())
except:
protein_sidechains = MoleculeGroup()
try:
protein_backbones = loadsys[MGName("protein_backbones")]
all_proteins.add(protein_backbones.molecules())
except:
protein_backbones = MoleculeGroup()
try:
boundary_molecules = loadsys[MGName("boundary_molecules")]
all_proteins.add(boundary_molecules.molecules())
except:
boundary_molecules = MoleculeGroup()
for molnum in all_proteins.molNums():
protein_mol = Molecule.join(all_proteins[molnum])
if protein_mol.selectedAll():
protein_intra_group.add(protein_mol)
all_group.add(protein_mol)
mobile_protein = []
if protein_sidechains.contains(molnum):
sidechains = protein_sidechains[molnum]
for sidechain in sidechains:
mobile_protein_sidechains_group.add(sidechain)
mobile_protein += sidechains
if protein_backbones.contains(molnum):
backbones = protein_backbones[molnum]
for backbone in backbones:
mobile_protein_backbones_group.add(backbone)
mobile_protein += backbones
if len(mobile_protein) > 0:
mobile_proteins_group.add(Molecule.join(mobile_protein))
else:
# only some of the atoms have been selected. We will extract
# the mobile atoms and will then update all of the other selections
print("Extracting the mobile atoms of protein %s" %
protein_mol.molecule())
new_protein_mol = protein_mol.extract()
print("Extracted %d mobile atoms from %d total atoms..." % \
(new_protein_mol.nAtoms(), protein_mol.molecule().nAtoms()))
protein_intra_group.add(new_protein_mol)
all_group.add(new_protein_mol)
mobile_protein_view = new_protein_mol.selection()
mobile_protein_view = mobile_protein_view.selectNone()
if protein_sidechains.contains(molnum):
sidechains = protein_sidechains[molnum]
for sidechain in sidechains:
view = new_protein_mol.selection()
view = view.selectNone()
for atomid in sidechain.selection().selectedAtoms():
atom = protein_mol.atom(atomid)
resatomid = ResAtomID(atom.residue().number(),
atom.name())
view = view.select(resatomid)
mobile_protein_view = mobile_protein_view.select(
resatomid)
if view.nSelected() > 0:
mobile_protein_sidechains_group.add(
PartialMolecule(new_protein_mol, view))
if protein_backbones.contains(molnum):
backbones = protein_backbones[molnum]
for backbone in backbones:
view = new_protein_mol.selection()
view = view.selectNone()
for atomid in backbone.selection().selectedAtoms():
atom = protein_mol.atom(atomid)
resatomid = ResAtomID(atom.residue().number(),
atom.name())
view = view.select(resatomid)
mobile_protein_view = mobile_protein_view.select(
resatomid)
if view.nSelected() > 0:
mobile_protein_backbones_group.add(
PartialMolecule(new_protein_mol, view))
print("Number of moved protein sidechain residues = %s" %
mobile_protein_sidechains_group.nViews())
print("Number of moved protein backbone residues = %s" %
mobile_protein_backbones_group.nViews())
if mobile_protein_view.nSelected() > 0:
mobile_proteins_group.add(
PartialMolecule(new_protein_mol, mobile_protein_view))
groups.append(mobile_protein_backbones_group)
groups.append(mobile_protein_sidechains_group)
groups.append(all_group)
# finished added in all of the proteins
for group in groups:
if group.nMolecules() > 0:
print("Adding group %s" % group.name())
system.add(group)
# now add in the forcefields for the system...
print("Creating the forcefields for the QM/MM system...")
# first, group together the molecules grouped above into convenient
# groups for the forcefields
# group holding just the ligand
ligand_mols = ligand_group.molecules()
# group holding all of the mobile atoms
mobile_mols = mobile_solvents_group.molecules()
mobile_mols.add(mobile_solutes_group.molecules())
mobile_mols.add(protein_intra_group.molecules())
# group holding all of the mobile atoms in the bound leg, excluding the
# buffer atoms that are fixed, but bonded to mobile atoms
mobile_buffered_mols = mobile_solvents_group.molecules()
mobile_buffered_mols.add(mobile_solutes_group.molecules())
mobile_buffered_mols.add(mobile_proteins_group.molecules())
# group holding all of the protein molecules that need intramolecular terms calculated
protein_intra_mols = protein_intra_group.molecules()
# group holding all of the solute molecules that nede intramolecular terms calculated
solute_intra_mols = mobile_solutes_group.molecules()
forcefields = []
###
### INTRA-ENERGY OF THE LIGAND AND CLUSTER
###
# intramolecular energy of the ligand
ligand_intraclj = IntraCLJFF("ligand:intraclj")
ligand_intraclj = setCLJProperties(ligand_intraclj, space)
ligand_intraclj.add(ligand_mols)
ligand_intraff = InternalFF("ligand:intra")
ligand_intraff.add(ligand_mols)
forcefields.append(ligand_intraclj)
forcefields.append(ligand_intraff)
ligand_mm_nrg = ligand_intraclj.components().total(
) + ligand_intraff.components().total()
###
### FORCEFIELDS INVOLVING THE LIGAND/CLUSTER AND OTHER ATOMS
###
# forcefield holding the energy between the ligand and the mobile atoms in the
# bound leg
ligand_mobile = InterGroupCLJFF("system:ligand-mobile")
ligand_mobile = setCLJProperties(ligand_mobile, space)
ligand_mobile.add(ligand_mols, MGIdx(0))
ligand_mobile.add(mobile_mols, MGIdx(1))
qm_ligand = QMMMFF("system:ligand-QM")
qm_ligand.add(ligand_mols, MGIdx(0))
qm_ligand = setQMProperties(qm_ligand, space)
zero_energy = 0
if not intermolecular_only.val:
if qm_zero_energy.val is None:
# calculate the delta value for the system - this is the difference between
# the MM and QM intramolecular energy of the ligand
t.start()
print("\nComparing the MM and QM energies of the ligand...")
mm_intra = ligand_intraclj.energy().value(
) + ligand_intraff.energy().value()
print("MM energy = %s kcal mol-1 (took %s ms)" %
(mm_intra, t.elapsed()))
t.start()
zero_sys = System()
zero_sys.add(qm_ligand)
qm_intra = zero_sys.energy().value()
print("QM energy = %s kcal mol-1 (took %s ms)" %
(qm_intra, t.elapsed()))
print("\nSetting the QM zero energy to %s kcal mol-1" %
(qm_intra - mm_intra))
qm_ligand.setZeroEnergy((qm_intra - mm_intra) * kcal_per_mol)
zero_energy = qm_intra - mm_intra
else:
print("\nManually setting the QM zero energy to %s" %
qm_zero_energy.val)
qm_ligand.setZeroEnergy(qm_zero_energy.val)
zero_energy = qm_zero_energy.val
qm_ligand.add(mobile_mols, MGIdx(1))
ligand_mm_nrg += ligand_mobile.components().total()
ligand_qm_nrg = qm_ligand.components().total() + ligand_mobile.components(
).lj()
if intermolecular_only.val:
# the QM model still uses the MM intramolecular energy of the ligand
ligand_qm_nrg += ligand_intraclj.components().total(
) + ligand_intraff.components().total()
forcefields.append(ligand_mobile)
forcefields.append(qm_ligand)
if fixed_group.nMolecules() > 0:
# there are fixed molecules
# Whether or not to disable the grid and calculate all energies atomisticly
if disable_grid:
# we need to renumber all of the fixed molecules so that they don't clash
# with the mobile molecules
print("Renumbering fixed molecules...")
fixed_group = renumberMolecules(fixed_group)
# forcefield holding the energy between the ligand and the fixed atoms in the bound leg
if disable_grid:
ligand_fixed = InterGroupCLJFF("system:ligand-fixed")
ligand_fixed = setCLJProperties(ligand_fixed, space)
ligand_fixed = setFakeGridProperties(ligand_fixed, space)
ligand_fixed.add(ligand_mols, MGIdx(0))
ligand_fixed.add(fixed_group, MGIdx(1))
qm_ligand.add(fixed_group, MGIdx(1))
ligand_mm_nrg += ligand_fixed.components().total()
ligand_qm_nrg += ligand_fixed.components().lj()
forcefields.append(ligand_fixed)
else:
ligand_fixed = GridFF2("system:ligand-fixed")
ligand_fixed = setCLJProperties(ligand_fixed, space)
ligand_fixed = setGridProperties(ligand_fixed)
ligand_fixed.add(ligand_mols, MGIdx(0))
ligand_fixed.addFixedAtoms(fixed_group)
qm_ligand.addFixedAtoms(fixed_group)
ligand_mm_nrg += ligand_fixed.components().total()
ligand_qm_nrg += ligand_fixed.components().lj()
forcefields.append(ligand_fixed)
###
### FORCEFIELDS NOT INVOLVING THE LIGAND
###
# forcefield holding the intermolecular energy between all molecules
mobile_mobile = InterCLJFF("mobile-mobile")
mobile_mobile = setCLJProperties(mobile_mobile, space)
mobile_mobile.add(mobile_mols)
other_nrg = mobile_mobile.components().total()
forcefields.append(mobile_mobile)
# forcefield holding the energy between the mobile atoms and
# the fixed atoms
if disable_grid.val:
mobile_fixed = InterGroupCLJFF("mobile-fixed")
mobile_fixed = setCLJProperties(mobile_fixed)
mobile_fixed = setFakeGridProperties(mobile_fixed, space)
mobile_fixed.add(mobile_buffered_mols, MGIdx(0))
mobile_fixed.add(fixed_group, MGIdx(1))
other_nrg += mobile_fixed.components().total()
forcefields.append(mobile_fixed)
else:
mobile_fixed = GridFF2("mobile-fixed")
mobile_fixed = setCLJProperties(mobile_fixed, space)
mobile_fixed = setGridProperties(mobile_fixed)
# we use mobile_buffered_group as this group misses out atoms that are bonded
# to fixed atoms (thus preventing large energies caused by incorrect non-bonded calculations)
mobile_fixed.add(mobile_buffered_mols, MGIdx(0))
mobile_fixed.addFixedAtoms(fixed_group)
other_nrg += mobile_fixed.components().total()
forcefields.append(mobile_fixed)
# intramolecular energy of the protein
if protein_intra_mols.nMolecules() > 0:
protein_intraclj = IntraCLJFF("protein_intraclj")
protein_intraclj = setCLJProperties(protein_intraclj, space)
protein_intraff = InternalFF("protein_intra")
for molnum in protein_intra_mols.molNums():
protein_mol = Molecule.join(protein_intra_mols[molnum])
protein_intraclj.add(protein_mol)
protein_intraff.add(protein_mol)
other_nrg += protein_intraclj.components().total()
other_nrg += protein_intraff.components().total()
forcefields.append(protein_intraclj)
forcefields.append(protein_intraff)
# intramolecular energy of any other solutes
if solute_intra_mols.nMolecules() > 0:
solute_intraclj = IntraCLJFF("solute_intraclj")
solute_intraclj = setCLJProperties(solute_intraclj, space)
solute_intraff = InternalFF("solute_intra")
for molnum in solute_intra_mols.molNums():
solute_mol = Molecule.join(solute_intra_mols[molnum])
solute_intraclj.add(solute_mol)
solute_intraff.add(solute_mol)
other_nrg += solute_intraclj.components().total()
other_nrg += solute_intraff.components().total()
forcefields.append(solute_intraclj)
forcefields.append(solute_intraff)
###
### NOW ADD THE FORCEFIELDS TO THE SYSTEM
###
###
### SETTING THE FORCEFIELD EXPRESSIONS
###
lam = Symbol("lambda")
e_slow = ((1 - lam) * ligand_qm_nrg) + (lam * ligand_mm_nrg) + other_nrg
e_fast = ligand_mm_nrg + other_nrg
de_by_dlam = ligand_mm_nrg - ligand_qm_nrg
for forcefield in forcefields:
system.add(forcefield)
system.setConstant(lam, 0.0)
system.setComponent(Symbol("E_{fast}"), e_fast)
system.setComponent(Symbol("E_{slow}"), e_slow)
system.setComponent(Symbol("dE/dlam"), de_by_dlam)
system.setComponent(system.totalComponent(), e_slow)
system.setProperty("space", space)
if space.isPeriodic():
# ensure that all molecules are wrapped into the space with the ligand at the center
print("Adding in a space wrapper constraint %s, %s" %
(space, ligand_mol.evaluate().center()))
system.add(SpaceWrapper(ligand_mol.evaluate().center(), all_group))
system.applyConstraints()
print("\nHere are the values of all of the initial energy components...")
t.start()
printEnergies(system.energies())
print("(these took %d ms to evaluate)\n" % t.elapsed())
# Create a monitor to monitor the free energy average
system.add("dG/dlam",
MonitorComponent(Symbol("dE/dlam"), AverageAndStddev()))
if intermolecular_only.val:
print(
"\n\n## This simulation uses QM to model *only* the intermolecular energy between"
)
print(
"## the QM and MM atoms. The intramolecular energy of the QM atoms is still"
)
print("## modelled using MM.\n")
else:
print(
"\n\n## This simulation uses QM to model both the intermolecular and intramolecular"
)
print(
"## energies of the QM atoms. Because the this, we have to adjust the 'zero' point"
)
print(
"## of the QM potential. You need to add the value %s kcal mol-1 back onto the"
% zero_energy)
print("## QM->MM free energy calculated using this program.\n")
return system
def createSystemFrom(molecules, space, system_name, naming_scheme = NamingScheme()):
"""Create a new System from the passed molecules and space,
sorting the molecules into different molecule groups based on the
passed naming scheme"""
system = System(system_name)
# If requested, change the water model for all water molecules
if water_model.val == "tip4p":
molnums = molecules.molNums()
new_molecules = Molecules()
print("Forcing all water molecules to use the %s water model..." % water_model.val)
print("Converting %d molecules..." % len(molnums))
i = 0
for molnum in molnums:
molecule = molecules[molnum].molecule()
if i % 100 == 0:
print("%d" % i)
sys.stdout.flush()
elif i % 10 == 0:
print(".", end=' ')
sys.stdout.flush()
i += 1
if molecule.nAtoms() == 3:
# this could be a TIP3P water
resname =str(molecule.residue().name().value()).lower()
if resname == "wat" or resname == "t3p":
new_molecule = convertTip3PtoTip4P(molecule)
if new_molecule:
molecule = new_molecule
new_molecules.add(molecule)
print("%d" % i)
molecules = new_molecules
nmols = molecules.nMolecules()
print("Number of molecules == %s" % nmols)
print("System space == %s" % space)
if nmols == 0:
return system
print("Assigning molecules to molecule groups...")
solute_group = MoleculeGroup(naming_scheme.solutesGroupName().value())
protein_group = MoleculeGroup(naming_scheme.proteinsGroupName().value())
solvent_group = MoleculeGroup(naming_scheme.solventsGroupName().value())
water_group = MoleculeGroup(naming_scheme.watersGroupName().value())
ion_group = MoleculeGroup(naming_scheme.ionsGroupName().value())
all_group = MoleculeGroup(naming_scheme.allMoleculesGroupName().value())
# The all molecules group has all of the molecules
all_group.add(molecules)
system.add(all_group)
# Run through each molecule and decide what type it is...
molnums = molecules.molNums()
molnums.sort()
central_molecule = None
solutes = []
proteins = []
solvents = []
waters = []
ions = []
for molnum in molnums:
molecule = molecules[molnum].molecule()
resnams = getResidueNames(molecule)
if naming_scheme.isSolute(resnams):
solutes.append(molecule)
elif naming_scheme.isProtein(resnams):
proteins.append(molecule)
elif naming_scheme.isWater(resnams):
waters.append(molecule)
elif naming_scheme.isIon(resnams):
ions.append(molecule)
elif molecule.nResidues() == 1:
solvents.append(molecule)
else:
solutes.append(molecule)
# Ok - we have now divided everything up into groups
for solute in solutes:
solute_group.add(solute)
for protein in proteins:
protein_group.add(protein)
for water in waters:
solvent_group.add(water)
water_group.add(water)
for solvent in solvents:
solvent_group.add(solvent)
for ion in ions:
solvent_group.add(ion)
ion_group.add(ion)
if solute_group.nMolecules() > 0:
system.add(solute_group)
if protein_group.nMolecules() > 0:
system.add(protein_group)
if solvent_group.nMolecules() > 0:
system.add(solvent_group)
if water_group.nMolecules() > 0:
system.add(water_group)
if ion_group.nMolecules() > 0:
system.add(ion_group)
print("Number of solute molecules == %s" % solute_group.nMolecules())
print("Number of protein molecules == %s" % protein_group.nMolecules())
print("Number of ions == %s" % ion_group.nMolecules())
print("Number of water molecules == %s" % water_group.nMolecules())
print("Number of solvent molecules == %s" % solvent_group.nMolecules())
print("(solvent group is waters + ions + unidentified single-residue molecules)")
system.setProperty("space", space)
system.add( SpaceWrapper( Vector(0), all_group ) )
system.applyConstraints()
print("Returning the constructed system")
return system
def test_system(verbose=False):
cljff = InterCLJFF()
mincoords = Vector(-18.3854, -18.66855, -18.4445)
maxcoords = Vector(18.3854, 18.66855, 18.4445)
vol = PeriodicBox(mincoords, maxcoords)
cljff.setSpace(vol)
mols = PDB().read("../io/water.pdb")
if verbose:
print("Read in %d molecules!" % mols.nMolecules())
i = 0
mol = mols.moleculeAt(0).molecule()
mol = mol.edit().atom( AtomName("O00") ) \
.setProperty("LJ", LJParameter(3.15363*angstrom, \
0.1550*kcal_per_mol)).molecule() \
.atom( AtomName("H01") ) \
.setProperty("charge", 0.520 * mod_electron).molecule() \
.atom( AtomName("H02") ) \
.setProperty("charge", 0.520 * mod_electron).molecule() \
.atom( AtomName("M03") ) \
.setProperty("charge", -1.04 * mod_electron).molecule() \
.commit()
charges = mol.property("charge")
ljs = mol.property("LJ")
cljff.add(mol)
for i in range(1, mols.nMolecules()):
mol = mols.moleculeAt(i).molecule()
mol = mol.edit().setProperty("charge", charges) \
.setProperty("LJ", ljs) \
.commit()
cljff.add(mol)
system = System()
system.add(cljff)
nrg = system.energy()
if verbose:
print("System energy = %s" % (nrg))
copy_system = System(system)
nrg2 = copy_system.energy()
if verbose:
print("Copy energy: %s (should be %s)" % (nrg2, nrg))
assert_almost_equal(nrg.value(), nrg2.value(), 5)
copy_system.mustNowRecalculateFromScratch()
nrg3 = copy_system.energy()
if verbose:
print("Copy energy: %s (should be %s)" % (nrg2, nrg))
assert_almost_equal(nrg.value(), nrg3.value(), 5)
(mols, space) = Amber().readCrdTop("l7n.crd", "l7n.top")
# extract the protein molecule (molecule with residue called "ALA")
protein_mol = mols[ MolWithResID("ALA") ].molecule()
# Create the 'protein' molecule group
protein = MoleculeGroup("protein")
# add the protein molecule to this group
protein.add( protein_mol )
# Create a system to hold the system to be simulated
system = System()
# Add the protein to the system
system.add(protein)
# create a forcefield to calculate the intramolecular
# Coulomb and Lennard-Jones energies of the protein (CLJ)
cljff = IntraFF("cljff")
# Use a shift-electrostatics with a 10 angstrom cutoff
cljff.setCLJFunction( CLJIntraShiftFunction(10*angstrom) )
# Add the protein
cljff.add(protein)
# Now also add a forcefield to calculate the intramolecular
# bond, angle and dihedral energy of the protein
intraff = InternalFF("intraff")
def loadQMMMSystem():
"""This function is called to set up the system. It sets everything
up, then returns a System object that holds the configured system"""
print("Loading the system...")
t = QTime()
if os.path.exists(s3file.val):
print("Loading existing s3 file %s..." % s3file.val)
loadsys = Sire.Stream.load(s3file.val)
else:
print("Loading from Amber files %s / %s..." % (topfile.val, crdfile.val))
# Add the name of the ligand to the list of solute molecules
sys_scheme = NamingScheme()
sys_scheme.addSoluteResidueName(ligand_name.val)
# Load up the system. This will automatically find the protein, solute, water, solvent
# and ion molecules and assign them to different groups
loadsys = createSystem(topfile.val, crdfile.val, sys_scheme)
ligand_mol = findMolecule(loadsys, ligand_name.val)
if ligand_mol is None:
print("Cannot find the ligand (%s) in the set of loaded molecules!" % ligand_name.val)
sys.exit(-1)
# Center the system with the ligand at (0,0,0)
loadsys = centerSystem(loadsys, ligand_mol)
ligand_mol = loadsys[ligand_mol.number()].molecule()
if reflection_radius.val is None:
loadsys = addFlexibility(loadsys, naming_scheme=sys_scheme )
else:
loadsys = addFlexibility(loadsys, Vector(0), reflection_radius.val, naming_scheme=sys_scheme)
Sire.Stream.save(loadsys, s3file.val)
ligand_mol = findMolecule(loadsys, ligand_name.val)
if ligand_mol is None:
print("Cannot find the ligand (%s) in the set of loaded molecules!" % ligand_name.val)
sys.exit(-1)
# Now build the QM/MM system
system = System("QMMM system")
if loadsys.containsProperty("reflection center"):
reflect_center = loadsys.property("reflection center").toVector()[0]
reflect_radius = float(str(loadsys.property("reflection sphere radius")))
system.setProperty("reflection center", AtomCoords(CoordGroup(1,reflect_center)))
system.setProperty("reflection sphere radius", VariantProperty(reflect_radius))
space = Cartesian()
else:
space = loadsys.property("space")
if loadsys.containsProperty("average solute translation delta"):
system.setProperty("average solute translation delta", \
loadsys.property("average solute translation delta"))
if loadsys.containsProperty("average solute rotation delta"):
system.setProperty("average solute rotation delta", \
loadsys.property("average solute rotation delta"))
# create a molecule group to hold all molecules
all_group = MoleculeGroup("all")
# create a molecule group for the ligand
ligand_group = MoleculeGroup("ligand")
ligand_group.add(ligand_mol)
all_group.add(ligand_mol)
groups = []
groups.append(ligand_group)
# pull out the groups that we want from the two systems
# create a group to hold all of the fixed molecules in the bound leg
fixed_group = MoleculeGroup("fixed_molecules")
if MGName("fixed_molecules") in loadsys.mgNames():
fixed_group.add( loadsys[ MGName("fixed_molecules") ] )
if save_pdb.val:
# write a PDB of the fixed atoms in the bound and free legs
if not os.path.exists(outdir.val):
os.makedirs(outdir.val)
PDB().write(fixed_group, "%s/fixed.pdb" % outdir.val)
# create a group to hold all of the mobile solute molecules
mobile_solutes_group = MoleculeGroup("mobile_solutes")
if MGName("mobile_solutes") in loadsys.mgNames():
mobile_solutes_group.add( loadsys[MGName("mobile_solutes")] )
mobile_solutes_group.remove(ligand_mol)
if mobile_solutes_group.nMolecules() > 0:
all_group.add(mobile_solutes_group)
groups.append(mobile_solutes_group)
# create a group to hold all of the mobile solvent molecules
mobile_solvents_group = MoleculeGroup("mobile_solvents")
if MGName("mobile_solvents") in loadsys.mgNames():
mols = loadsys[MGName("mobile_solvents")]
for molnum in mols.molNums():
solvent_mol = mols[molnum].molecule()
mobile_solvents_group.add(solvent_mol)
all_group.add(mobile_solvents_group)
print("The number of mobile solvent molecules is %d." % mobile_solvents_group.nMolecules())
groups.append(mobile_solvents_group)
# create the groups to hold all of the protein molecules. We will use "extract" to
# pull out only those protein atoms that are in the mobile region
protein_intra_group = MoleculeGroup("protein_intra_group")
mobile_proteins_group = MoleculeGroup("proteins")
mobile_protein_sidechains_group = MoleculeGroup("mobile_sidechains")
mobile_protein_backbones_group = MoleculeGroup("mobile_backbones")
if MGName("protein_sidechains") in loadsys.mgNames() or \
MGName("protein_backbones") in loadsys.mgNames():
all_proteins = Molecules()
try:
protein_sidechains = loadsys[MGName("protein_sidechains")]
all_proteins.add(protein_sidechains.molecules())
except:
protein_sidechains = MoleculeGroup()
try:
protein_backbones = loadsys[MGName("protein_backbones")]
all_proteins.add(protein_backbones.molecules())
except:
protein_backbones = MoleculeGroup()
try:
boundary_molecules = loadsys[MGName("boundary_molecules")]
all_proteins.add(boundary_molecules.molecules())
except:
boundary_molecules = MoleculeGroup()
for molnum in all_proteins.molNums():
protein_mol = all_proteins[molnum].join()
if protein_mol.selectedAll():
protein_intra_group.add(protein_mol)
all_group.add(protein_mol)
mobile_protein = None
try:
mobile_protein = protein_sidechains[molnum]
mobile_protein_sidechains_group.add( mobile_protein )
except:
pass
try:
if mobile_protein is None:
mobile_protein = protein_backbones[molnum]
mobile_protein_backbones_group.add( mobile_protein )
else:
mobile_protein.add( protein_backbones[molnum].selection() )
mobile_protein_backbones_group.add( protein_backbones[molnum] )
except:
pass
if not (mobile_protein is None):
mobile_proteins_group.add( mobile_protein.join() )
else:
# only some of the atoms have been selected. We will extract
# the mobile atoms and will then update all of the other selections
print("Extracting the mobile atoms of protein %s" % protein_mol)
new_protein_mol = protein_mol.extract()
print("Extracted %d mobile atoms from %d total atoms..." % \
(new_protein_mol.nAtoms(), protein_mol.molecule().nAtoms()))
protein_intra_group.add(new_protein_mol)
all_group.add( new_protein_mol )
mobile_protein_view = new_protein_mol.selection()
mobile_protein_view = mobile_protein_view.selectNone()
try:
sidechains = protein_sidechains[molnum]
for i in range(0,sidechains.nViews()):
view = new_protein_mol.selection()
view = view.selectNone()
for atomid in sidechains.viewAt(i).selectedAtoms():
atom = protein_mol.atom(atomid)
resatomid = ResAtomID( atom.residue().number(), atom.name() )
view = view.select( resatomid )
mobile_protein_view = mobile_protein_view.select( resatomid )
if view.nSelected() > 0:
mobile_protein_sidechains_group.add( PartialMolecule(new_protein_mol, view) )
except:
pass
try:
backbones = protein_backbones[molnum]
for i in range(0,backbones.nViews()):
view = new_protein_mol.selection()
view = view.selectNone()
for atomid in backbones.viewAt(i).selectedAtoms():
atom = protein_mol.atom(atomid)
resatomid = ResAtomID( atom.residue().number(), atom.name() )
view = view.select( resatomid )
mobile_protein_view = mobile_protein_view.select( resatomid )
if view.nSelected() > 0:
mobile_protein_backbones_group.add( PartialMolecule(new_protein_mol, view) )
except:
pass
if mobile_protein_view.nSelected() > 0:
mobile_proteins_group.add( PartialMolecule(new_protein_mol, mobile_protein_view) )
groups.append(mobile_protein_backbones_group)
groups.append(mobile_protein_sidechains_group)
groups.append(all_group)
# finished added in all of the proteins
for group in groups:
if group.nMolecules() > 0:
print("Adding group %s" % group.name())
system.add(group)
# now add in the forcefields for the system...
print("Creating the forcefields for the QM/MM system...")
# first, group together the molecules grouped above into convenient
# groups for the forcefields
# group holding just the ligand
ligand_mols = ligand_group.molecules()
# group holding all of the mobile atoms
mobile_mols = mobile_solvents_group.molecules()
mobile_mols.add( mobile_solutes_group.molecules() )
mobile_mols.add( protein_intra_group.molecules() )
# group holding all of the mobile atoms in the bound leg, excluding the
# buffer atoms that are fixed, but bonded to mobile atoms
mobile_buffered_mols = mobile_solvents_group.molecules()
mobile_buffered_mols.add( mobile_solutes_group.molecules() )
mobile_buffered_mols.add( mobile_proteins_group.molecules() )
# group holding all of the protein molecules that need intramolecular terms calculated
protein_intra_mols = protein_intra_group.molecules()
# group holding all of the solute molecules that nede intramolecular terms calculated
solute_intra_mols = mobile_solutes_group.molecules()
forcefields = []
###
### INTRA-ENERGY OF THE LIGAND AND CLUSTER
###
# intramolecular energy of the ligand
ligand_intraclj = IntraCLJFF("ligand:intraclj")
ligand_intraclj = setCLJProperties(ligand_intraclj, space)
ligand_intraclj.add(ligand_mols)
ligand_intraff = InternalFF("ligand:intra")
ligand_intraff.add(ligand_mols)
forcefields.append(ligand_intraclj)
forcefields.append(ligand_intraff)
ligand_mm_nrg = ligand_intraclj.components().total() + ligand_intraff.components().total()
###
### FORCEFIELDS INVOLVING THE LIGAND/CLUSTER AND OTHER ATOMS
###
# forcefield holding the energy between the ligand and the mobile atoms in the
# bound leg
ligand_mobile = InterGroupCLJFF("system:ligand-mobile")
ligand_mobile = setCLJProperties(ligand_mobile, space)
ligand_mobile.add(ligand_mols, MGIdx(0))
ligand_mobile.add(mobile_mols, MGIdx(1))
qm_ligand = QMMMFF("system:ligand-QM")
qm_ligand = setQMProperties(qm_ligand, space)
qm_ligand.add(ligand_mols, MGIdx(0))
zero_energy = 0
if not intermolecular_only.val:
if qm_zero_energy.val is None:
# calculate the delta value for the system - this is the difference between
# the MM and QM intramolecular energy of the ligand
t.start()
print("\nComparing the MM and QM energies of the ligand...")
mm_intra = ligand_intraclj.energy().value() + ligand_intraff.energy().value()
print("MM energy = %s kcal mol-1 (took %s ms)" % (mm_intra, t.elapsed()))
t.start()
qm_intra = qm_ligand.energy().value()
print("QM energy = %s kcal mol-1 (took %s ms)" % (qm_intra, t.elapsed()))
print("\nSetting the QM zero energy to %s kcal mol-1" % (qm_intra - mm_intra))
qm_ligand.setZeroEnergy( (qm_intra-mm_intra) * kcal_per_mol )
zero_energy = qm_intra - mm_intra
else:
print("\nManually setting the QM zero energy to %s" % qm_zero_energy.val)
qm_ligand.setZeroEnergy( qm_zero_energy.val )
zero_energy = qm_zero_energy.val
qm_ligand.add(mobile_mols, MGIdx(1))
ligand_mm_nrg += ligand_mobile.components().total()
ligand_qm_nrg = qm_ligand.components().total() + ligand_mobile.components().lj()
if intermolecular_only.val:
# the QM model still uses the MM intramolecular energy of the ligand
ligand_qm_nrg += ligand_intraclj.components().total() + ligand_intraff.components().total()
forcefields.append(ligand_mobile)
forcefields.append(qm_ligand)
if fixed_group.nMolecules() > 0:
# there are fixed molecules
# Whether or not to disable the grid and calculate all energies atomisticly
if disable_grid:
# we need to renumber all of the fixed molecules so that they don't clash
# with the mobile molecules
print("Renumbering fixed molecules...")
fixed_group = renumberMolecules(fixed_group)
# forcefield holding the energy between the ligand and the fixed atoms in the bound leg
if disable_grid:
ligand_fixed = InterGroupCLJFF("system:ligand-fixed")
ligand_fixed = setCLJProperties(ligand_fixed, space)
ligand_fixed = setFakeGridProperties(ligand_fixed, space)
ligand_fixed.add(ligand_mols, MGIdx(0))
ligand_fixed.add(fixed_group, MGIdx(1))
qm_ligand.add(fixed_group, MGIdx(1))
ligand_mm_nrg += ligand_fixed.components().total()
ligand_qm_nrg += ligand_fixed.components().lj()
forcefields.append(ligand_fixed)
else:
ligand_fixed = GridFF("system:ligand-fixed")
ligand_fixed = setCLJProperties(ligand_fixed, space)
ligand_fixed = setGridProperties(ligand_fixed)
ligand_fixed.add(ligand_mols, MGIdx(0))
ligand_fixed.addFixedAtoms( fixed_group )
qm_ligand.addFixedAtoms( fixed_group )
ligand_mm_nrg += ligand_fixed.components().total()
ligand_qm_nrg += ligand_fixed.components().lj()
forcefields.append(ligand_fixed)
###
### FORCEFIELDS NOT INVOLVING THE LIGAND
###
# forcefield holding the intermolecular energy between all molecules
mobile_mobile = InterCLJFF("mobile-mobile")
mobile_mobile = setCLJProperties(mobile_mobile, space)
mobile_mobile.add(mobile_mols)
other_nrg = mobile_mobile.components().total()
forcefields.append(mobile_mobile)
# forcefield holding the energy between the mobile atoms and
# the fixed atoms
if disable_grid.val:
mobile_fixed = InterGroupCLJFF("mobile-fixed")
mobile_fixed = setCLJProperties(mobile_fixed)
mobile_fixed = setFakeGridProperties(mobile_fixed, space)
mobile_fixed.add(mobile_buffered_mols, MGIdx(0))
mobile_fixed.add(fixed_group, MGIdx(1))
other_nrg += mobile_fixed.components().total()
forcefields.append(mobile_fixed)
else:
mobile_fixed = GridFF("mobile-fixed")
mobile_fixed = setCLJProperties(mobile_fixed, space)
mobile_fixed = setGridProperties(mobile_fixed)
# we use mobile_buffered_group as this group misses out atoms that are bonded
# to fixed atoms (thus preventing large energies caused by incorrect non-bonded calculations)
mobile_fixed.add(mobile_buffered_mols, MGIdx(0))
mobile_fixed.addFixedAtoms(fixed_group)
other_nrg += mobile_fixed.components().total()
forcefields.append(mobile_fixed)
# intramolecular energy of the protein
if protein_intra_mols.nMolecules() > 0:
protein_intraclj = IntraCLJFF("protein_intraclj")
protein_intraclj = setCLJProperties(protein_intraclj, space)
protein_intraff = InternalFF("protein_intra")
for molnum in protein_intra_mols.molNums():
protein_mol = protein_intra_mols[molnum].join()
protein_intraclj.add(protein_mol)
protein_intraff.add(protein_mol)
other_nrg += protein_intraclj.components().total()
other_nrg += protein_intraff.components().total()
forcefields.append(protein_intraclj)
forcefields.append(protein_intraff)
# intramolecular energy of any other solutes
if solute_intra_mols.nMolecules() > 0:
solute_intraclj = IntraCLJFF("solute_intraclj")
solute_intraclj = setCLJProperties(solute_intraclj, space)
solute_intraff = InternalFF("solute_intra")
for molnum in solute_intra_mols.molNums():
solute_mol = solute_intra_mols[molnum].join()
solute_intraclj.add(solute_mol)
solute_intraff.add(solute_mol)
other_nrg += solute_intraclj.components().total()
other_nrg += solute_intraff.components().total()
forcefields.append(solute_intraclj)
forcefields.append(solute_intraff)
###
### NOW ADD THE FORCEFIELDS TO THE SYSTEM
###
###
### SETTING THE FORCEFIELD EXPRESSIONS
###
lam = Symbol("lambda")
e_slow = ((1-lam) * ligand_qm_nrg) + (lam * ligand_mm_nrg) + other_nrg
e_fast = ligand_mm_nrg + other_nrg
de_by_dlam = ligand_mm_nrg - ligand_qm_nrg
for forcefield in forcefields:
system.add(forcefield)
system.setConstant(lam, 0.0)
system.setComponent(Symbol("E_{fast}"), e_fast)
system.setComponent(Symbol("E_{slow}"), e_slow)
system.setComponent(Symbol("dE/dlam"), de_by_dlam)
system.setComponent( system.totalComponent(), e_slow )
system.setProperty("space", space)
if space.isPeriodic():
# ensure that all molecules are wrapped into the space with the ligand at the center
print("Adding in a space wrapper constraint %s, %s" % (space, ligand_mol.evaluate().center()))
system.add( SpaceWrapper( ligand_mol.evaluate().center(), all_group ) )
system.applyConstraints()
print("\nHere are the values of all of the initial energy components...")
t.start()
printEnergies(system.energies())
print("(these took %d ms to evaluate)\n" % t.elapsed())
# Create a monitor to monitor the free energy average
system.add( "dG/dlam", MonitorComponent(Symbol("dE/dlam"), AverageAndStddev()) )
if intermolecular_only.val:
print("\n\n## This simulation uses QM to model *only* the intermolecular energy between")
print("## the QM and MM atoms. The intramolecular energy of the QM atoms is still")
print("## modelled using MM.\n")
else:
print("\n\n## This simulation uses QM to model both the intermolecular and intramolecular")
print("## energies of the QM atoms. Because the this, we have to adjust the 'zero' point")
print("## of the QM potential. You need to add the value %s kcal mol-1 back onto the" % zero_energy)
print("## QM->MM free energy calculated using this program.\n")
return system
intraclj = IntraCLJFF("IntraCLJ")
intraclj.add(mol)
print(intraff.energy())
print(intraclj.energy())
print(intraff.energy() + intraclj.energy())
print(qmff.energy())
solute = MoleculeGroup("solute")
solute.add(mol)
system = System()
system.add(qmff)
system.add(intraff)
system.add(intraclj)
system.add(solute)
print(system.energy())
chg_constraint = QMChargeConstraint(solute)
chg_constraint.setChargeCalculator( AM1BCC() )
system.add(chg_constraint)
print(system.constraintsSatisfied())
print(system.energy())
protoms_dir = os.getenv("HOME") + "/Work/ProtoMS"
protoms = ProtoMS( "%s/protoms2" % protoms_dir )
protoms.addParameterFile("%s/parameter/amber99.ff" % protoms_dir )
protoms.addParameterFile("%s/parameter/gaff.ff" % protoms_dir )
protoms.addParameterFile("test/ff/sb2.ff")
sb2 = protoms.parameterise(sb2, ProtoMS.SOLUTE)
qmff = QMFF("MopacFF")
mopac = Mopac()
qmff.setQuantumProgram( mopac )
qmff.add(sb2)
system = System()
system.add(qmff)
zmat_move = ZMatMove(qmff[MGIdx(0)])
moves = SameMoves(zmat_move)
import Sire.Stream
Sire.Stream.save( (system,moves), "test/Squire/mopacsim.s3" )
print("Energy before == %f kcal mol-1" % system.energy().to(kcal_per_mol))
system = moves.move(system)
print("Energy after == %f kcal mol-1" % system.energy().to(kcal_per_mol))
cljff.add(mol)
for i in range(1, mols.nMolecules()):
mol = mols.moleculeAt(i).molecule()
mol = mol.edit().rename("T4P") \
.setProperty("charge", charges) \
.setProperty("LJ", ljs) \
.commit()
cljff.add(mol)
mols.update(mol)
system = System()
system.add(cljff)
print("System energy equals...")
print(system.energy())
group0 = MoleculeGroup("group0")
group1 = MoleculeGroup("group1")
group0.add( mols.moleculeAt(100) )
group0.add( mols.moleculeAt(101) )
group1.add( mols.moleculeAt(102) )
group1.add( mols.moleculeAt(103) )
group1.add( mols.moleculeAt(104) )
cljff2 = InterGroupCLJFF("group_energy")
def calculateEnergy(lamval):
cljff01 = InterGroupCLJFF("cljff01")
cljff02 = InterGroupCLJFF("cljff02")
cljff01.add(water0, MGIdx(0))
cljff01.add(water1, MGIdx(1))
cljff02.add(water0, MGIdx(0))
cljff02.add(water2, MGIdx(1))
soft_cljff01 = InterGroupSoftCLJFF("soft_cljff01")
soft_cljff02 = InterGroupSoftCLJFF("soft_cljff02")
soft_cljff01.add(water0, MGIdx(0))
soft_cljff01.add(water1, MGIdx(1))
soft_cljff02.add(water0, MGIdx(0))
soft_cljff02.add(water2, MGIdx(1))
ref = MoleculeGroup("ref", water0)
group_a = MoleculeGroup("group_a", water1)
group_b = MoleculeGroup("group_b", water2)
dlam = 0.001
lamval_f = lamval + dlam
lam = Symbol("lambda")
lam_f = Symbol("lambda_f")
soft_nrg = (1 - lam) * soft_cljff01.components().total(
0) + lam * soft_cljff02.components().total(0)
soft_nrg_f = (1 - lam_f) * soft_cljff01.components().total(
1) + lam_f * soft_cljff02.components().total(1)
de_soft = soft_nrg_f - soft_nrg
nrg = ((1 - lam) *
cljff01.components().total()) + (lam * cljff02.components().total())
nrg_f = ((1 - lam_f) * cljff01.components().total()) + (
lam_f * cljff02.components().total())
de = nrg_f - nrg
soft_cljff01.setProperty("alpha0", VariantProperty(lamval))
soft_cljff02.setProperty("alpha0", VariantProperty(1 - lamval))
soft_cljff01.setProperty("alpha1", VariantProperty(lamval_f))
soft_cljff02.setProperty("alpha1", VariantProperty(1 - lamval_f))
soft_cljff01.setProperty("coulombPower", VariantProperty(0))
soft_cljff01.setProperty("shiftDelta", VariantProperty(1.1))
soft_cljff02.setProperty("coulombPower", VariantProperty(0))
soft_cljff02.setProperty("shiftDelta", VariantProperty(1.1))
sys = System()
sys.add(cljff01)
sys.add(cljff02)
sys.add(soft_cljff01)
sys.add(soft_cljff02)
sys.add(ref)
sys.add(group_a)
sys.add(group_b)
sys.setComponent(lam, lamval)
sys.setComponent(lam_f, lamval_f)
sys.setComponent(sys.totalComponent(), nrg)
sys.setComponent(Symbol("E_{total_f}"), nrg_f)
sys.setComponent(Symbol("dE"), de)
sys.setComponent(Symbol("E_soft_{total}"), soft_nrg)
sys.setComponent(Symbol("E_soft_{total_f}"), soft_nrg_f)
sys.setComponent(Symbol("dE_soft"), de_soft)
nrgmon = FreeEnergyMonitor(ref, group_a, group_b)
soft_nrgmon = FreeEnergyMonitor(ref, group_a, group_b)
soft_nrgmon.setCoulombPower(0)
soft_nrgmon.setShiftDelta(1.1)
sys.add("nrgmon", nrgmon)
sys.add("soft_nrgmon", soft_nrgmon)
sys.collectStats()
nrgmon = sys[MonitorName("nrgmon")]
dg = nrgmon.freeEnergies()[0].average()
soft_nrgmon = sys[MonitorName("soft_nrgmon")]
soft_dg = soft_nrgmon.freeEnergies()[0].average()
sys_dg = sys.energy(Symbol("dE")).value()
sys_soft_dg = sys.energy(Symbol("dE_soft")).value()
assert_almost_equal(dg, sys_dg, 5)
assert_almost_equal(soft_dg, sys_soft_dg, 5)
import Sire.Stream
# First, lets load up the parameterised water dimer from the s3 file
(first_water, second_water) = Sire.Stream.load("water_dimer.s3")
# Now we create the InterCLJFF and add the two water molecules
cljff = InterCLJFF("cljff")
cljff.add(first_water)
cljff.add(second_water)
# Sire performs simulations on simulation System objects.
# A System groups together all of the molecules, forcefields etc.
# into a single unit
system = System()
system.add(cljff)
# Here we create the equation used to calculate the total energy of the
# system. We define a symbol, lambda, which we use here to scale up and
# down the coulomb component of cljff
lam = Symbol("lambda")
total_nrg = cljff.components().lj() + lam * cljff.components().coulomb()
# Here we tell the system to use our equation to calculate the total
# energy, and we set the value of lambda to 0.5
system.setComponent( system.totalComponent(), total_nrg )
system.setConstant( lam, 0.5 )
# Now we create a MoleculeGroup that groups together all of the
# molecules to be moved
mobile_mols = MoleculeGroup("mobile_molecules")
cljff.add(mol)
for i in range(1, mols.nMolecules()):
mol = mols.moleculeAt(i).molecule()
mol = mol.edit().rename("T4P") \
.setProperty("charge", charges) \
.setProperty("LJ", ljs) \
.commit()
cljff.add(mol)
mols.update(mol)
system = System()
system.add(cljff)
print("System energy equals...")
print(system.energy())
group0 = MoleculeGroup("group0")
group1 = MoleculeGroup("group1")
group0.add(mols.moleculeAt(100))
group0.add(mols.moleculeAt(101))
group1.add(mols.moleculeAt(102))
group1.add(mols.moleculeAt(103))
group1.add(mols.moleculeAt(104))
cljff2 = InterGroupCLJFF("group_energy")
def estimateDG(topfile=None,crdfile=None,pertfile=None,
trajfile=None,librarypath=None):
"""
This subroutine loads a trajectory for an alchemical state, and a list of
ligand molecules
For each frame of the trajectory
for each perturbed ligand
Align the perturbed ligand onto reference ligand.
Generate K poses
Accumulate exp energy difference
Estimate (w bootstrapping) free energy difference & uncertainties
"""
print ("HELLO ESTIMATE DG")
# Setup system describing alchemical state
amber = Amber()
(molecules, space) = amber.readCrdTop(crdfile, topfile)
morphfile = Parameter("morphfile",pertfile,""".""")
system = createSystemFreeEnergy(molecules, morphfile=morphfile)
cutoff_type = Parameter(".","cutoffperiodic",""".""")
cutoff_dist = Parameter(".",10*angstrom,""".""")
rf_dielectric = Parameter(".",82.0,""".""")
shift_delta = Parameter(".",2.0,""".""")
coulomb_power = Parameter(".",0,""".""")
combining_rules = Parameter(".","arithmetic",""".""")
lambda_val = Parameter(".",0.0,""".""")
system = setupForceFieldsFreeEnergy(system, space, cutoff_type=cutoff_type,
cutoff_dist=cutoff_dist,
rf_dielectric=rf_dielectric,
shift_delta=shift_delta,
coulomb_power=coulomb_power,
combining_rules=combining_rules,
lambda_val=lambda_val)
# Load ligands library
# FIX ME ! Don't include ligands that have already been simulated !
library = loadLibrary(librarypath)
library_deltaenergies = {}
# library_deltaenergies contain the list of computed energy differences
for ligand in library:
library_deltaenergies[ligand] = []
#import pdb; pdb.set_trace()
# Now scan trajectory
start_frame = 1
end_frame = 3
step_frame = 1
trajfile = Parameter(".",trajfile,""".""")
mdtraj_trajfile = mdtraj.open(trajfile.val,'r')
nframes = len(mdtraj_trajfile)
if end_frame > (nframes - 1):
end_frame = nframes - 1
mdtraj_trajfile.seek(start_frame)
current_frame = start_frame
energies = {}
for (ID, ligand) in library:
energies[ID] = []
while (current_frame <= end_frame):
print ("#Processing frame %s " % current_frame)
frames_xyz, cell_lengths, cell_angles = mdtraj_trajfile.read(n_frames=1)
system = updateSystemfromTraj(system, frames_xyz, cell_lengths, cell_angles)
ref_ligand = system[MGName("solutes")].molecules().first().molecule()
ref_nrg = system.energy()
print (ref_nrg)
for (ID, ligand) in library:
# Align ligand onto reference ligand
mapping = AtomMCSMatcher(1*second).match(ref_ligand, PropertyMap(), ligand, PropertyMap())
mapper = AtomResultMatcher(mapping)
# This does a RB alignment
# TODO) Explore optimised alignment codes
# For instance could construct aligned ligand by reusing MCSS coordinates
# and completing topology for variable part using BAT internal coordinates
# Also, better otherwise never get intramolecular energy variations !
# Basic test...SAME LIGAND should give 0 energy difference !
# FIXME) Return multiple coordinates and update system in each instance
aligned_ligand = ligand.move().align(ref_ligand, AtomMatchInverter(mapper))
#print (ref_ligand.property("coordinates").toVector())
#print ("####")
#print (aligned_ligand.property("coordinates").toVector())
# FIXME) Optimise for speed
new_system = System()
new_space = system.property("space")
new_system.add( system[MGName("solvent")] )
sols = MoleculeGroup("solutes")
solref = MoleculeGroup("solute_ref")
solhard = MoleculeGroup("solute_ref_hard")
soltodummy = MoleculeGroup("solute_ref_todummy")
solfromdummy = MoleculeGroup("solute_ref_fromdummy")
sols.add(aligned_ligand)
solref.add(aligned_ligand)
solhard.add(aligned_ligand)
new_system.add(sols)
new_system.add(solref)
new_system.add(solhard)
new_system.add(soltodummy)
new_system.add(solfromdummy)
#print ("###")
# DONE) Optimise for speed, only doing ligand energies
#print (new_system[MGName("solutes")].first().molecule().property("coordinates").toVector())
new_system = setupForceFieldsFreeEnergy(new_system, new_space, cutoff_type=cutoff_type,
cutoff_dist=cutoff_dist,
rf_dielectric=rf_dielectric,
shift_delta=shift_delta,
coulomb_power=coulomb_power,
combining_rules=combining_rules,
lambda_val=lambda_val)
new_nrg = new_system.energy()
print (new_nrg)
energies[ID].append( new_nrg - ref_nrg )
# for each conformation generated
# consider further optimisation (rapid MC --> if loaded flex files?)
# update 'perturbed' group with aligned ligand coordinates
# compute 'perturbed' energy
# accumulate 'perturbed' - reference
#import pdb; pdb.set_trace()
current_frame += step_frame
import pdb; pdb.set_trace()
# Now convert accumulated data int
return 0
from Sire.Base import *
from Sire.FF import *
sys = System()
from Sire.Maths import *
box0 = PeriodicBox(Vector(10.0, 10.0, 10.0))
box1 = PeriodicBox(Vector(20.0, 20.0, 20.0))
print(box0)
print(box0.volume())
print(box1.volume())
from Sire.MM import *
sys.add(InterCLJFF("cljff"))
print(sys)
print(sys.property("space"))
print(sys.userProperties().propertyKeys())
print(sys.builtinProperties().propertyKeys())
sys.setProperty("space0", LinkToProperty("space", FFIdx(0)))
print(sys.property("space0"))
sys.setProperty("space0", box0)
print(sys.property("space"))
sys.setProperty("space1", box1)
def createSystemFreeEnergy(molecules, morphfile=None):
r"""creates the system for free energy calculation
Parameters
----------
molecules : Sire.molecules
Sire object that contains a lot of information about molecules
Returns
-------
system : Sire.system
"""
print ("Create the System...")
moleculeNumbers = molecules.molNums()
moleculeList = []
for moleculeNumber in moleculeNumbers:
molecule = molecules.molecule(moleculeNumber).molecule()
moleculeList.append(molecule)
#
# The code below assumes that the solute to be perturbed is
# the first molecule in the top file.
# The residue name of the first residue in this molecule is
# used to name the solute. This is used later to match
# templates in the flex/pert files.
solute = moleculeList[0]
lig_name = solute.residue(ResIdx(0)).name().value()
solute = solute.edit().rename(lig_name).commit()
perturbations_lib = PerturbationsLibrary(morphfile.val)
solute = perturbations_lib.applyTemplate(solute)
perturbations = solute.property("perturbations")
lam = Symbol("lambda")
initial = Perturbation.symbols().initial()
final = Perturbation.symbols().final()
solute = solute.edit().setProperty("perturbations",
perturbations.recreate((1 - lam) * initial + lam * final)).commit()
# We put atoms in three groups depending on what happens in the perturbation
# non dummy to non dummy --> the hard group, uses a normal intermolecular FF
# non dummy to dummy --> the todummy group, uses SoftFF with alpha = Lambda
# dummy to non dummy --> the fromdummy group, uses SoftFF with alpha = 1 - Lambda
# We start assuming all atoms are hard atoms. Then we call getDummies to find which atoms
# start/end as dummies and update the hard, todummy and fromdummy groups accordingly
solute_grp_ref = MoleculeGroup("solute_ref", solute)
solute_grp_ref_hard = MoleculeGroup("solute_ref_hard")
solute_grp_ref_todummy = MoleculeGroup("solute_ref_todummy")
solute_grp_ref_fromdummy = MoleculeGroup("solute_ref_fromdummy")
solute_ref_hard = solute.selectAllAtoms()
solute_ref_todummy = solute_ref_hard.invert()
solute_ref_fromdummy = solute_ref_hard.invert()
to_dummies, from_dummies = getDummies(solute)
if to_dummies is not None:
ndummies = to_dummies.count()
dummies = to_dummies.atoms()
for x in range(0, ndummies):
dummy_index = dummies[x].index()
solute_ref_hard = solute_ref_hard.subtract(solute.select(dummy_index))
solute_ref_todummy = solute_ref_todummy.add(solute.select(dummy_index))
if from_dummies is not None:
ndummies = from_dummies.count()
dummies = from_dummies.atoms()
for x in range(0, ndummies):
dummy_index = dummies[x].index()
solute_ref_hard = solute_ref_hard.subtract(solute.select(dummy_index))
solute_ref_fromdummy = solute_ref_fromdummy.add(solute.select(dummy_index))
solute_grp_ref_hard.add(solute_ref_hard)
solute_grp_ref_todummy.add(solute_ref_todummy)
solute_grp_ref_fromdummy.add(solute_ref_fromdummy)
solutes = MoleculeGroup("solutes")
solutes.add(solute)
molecules = MoleculeGroup("molecules")
molecules.add(solute)
solvent = MoleculeGroup("solvent")
for molecule in moleculeList[1:]:
molecules.add(molecule)
solvent.add(molecule)
all = MoleculeGroup("all")
all.add(molecules)
all.add(solvent)
all.add(solutes)
all.add(solute_grp_ref)
all.add(solute_grp_ref_hard)
all.add(solute_grp_ref_todummy)
all.add(solute_grp_ref_fromdummy)
# Add these groups to the System
system = System()
system.add(solutes)
system.add(solute_grp_ref)
system.add(solute_grp_ref_hard)
system.add(solute_grp_ref_todummy)
system.add(solute_grp_ref_fromdummy)
system.add(molecules)
system.add(solvent)
system.add(all)
return system
cljff.setSwitchingFunction(switchfunc)
# We now need to add all of the water molecules to this forcefield,
# telling it to get the charges from the "charge" property, and the
# LJ parameters from the "LJ" property
cljff.add( waters, {"charge" : "charge", "LJ" : "LJ"} )
# Note that "charge" and "LJ" are the default names, so we could
# have just written 'cljff.add(waters)'
# Now create a simulation System - this holds all of the molecules,
# forcefields and monitors
system = System()
# Add the CLJ forcefield to the system
system.add(cljff)
# Add the molecule group containing the waters to the system - we will give
# this molecule group the name 'waters' so that we can extract it from
# the system at a later point in the script
waters.setName("waters")
system.add(waters)
# Add a constraint that waters are mapped back into the periodic box
system.add( SpaceWrapper(Vector(0,0,0), waters) )
print "Calculating the starting energy... (should be -16364.5 kcal mol-1)"
print "...Initial energy = %s" % system.energy()
# Now create the rigid body move (RigidBodyMC, from Sire.Move) that act on the waters
rbmc = RigidBodyMC(waters)
def makeSim(system, ligand_mol, watersys):
"""Create simulation systems with and without the ligand and return those systems together
with the moves"""
stage1 = System("with_ligand")
stage2 = System("without_ligand")
if system.containsProperty("reflection center"):
reflection_center = system.property("reflection center").toVector()[0]
reflection_radius = float(
str(system.property("reflection sphere radius")))
stage1.setProperty("reflection center",
AtomCoords(CoordGroup(1, reflection_center)))
stage1.setProperty("reflection sphere radius",
VariantProperty(reflection_radius))
stage2.setProperty("reflection center",
AtomCoords(CoordGroup(1, reflection_center)))
stage2.setProperty("reflection sphere radius",
VariantProperty(reflection_radius))
# create a molecule group for fixed atoms (everything except the mobile water)
fixed_group = MoleculeGroup("fixed")
if MGName("fixed_molecules") in system.mgNames():
fixed_group.add(system[MGName("fixed_molecules")])
if MGName("mobile_solutes") in system.mgNames():
fixed_group.add(system[MGName("mobile_solutes")])
if MGName("protein_sidechains") in system.mgNames() or \
MGName("protein_backbones") in system.mgNames():
all_proteins = Molecules()
try:
protein_sidechains = system[MGName("protein_sidechains")]
all_proteins.add(protein_sidechains.molecules())
except:
pass
try:
protein_backbones = system[MGName("protein_backbones")]
all_proteins.add(protein_backbones.molecules())
except:
pass
try:
boundary_molecules = system[MGName("boundary_molecules")]
all_proteins.add(boundary_molecules.molecules())
except:
pass
for molnum in all_proteins.molNums():
protein_mol = Molecule.join(all_proteins[molnum])
fixed_group.add(protein_mol)
stage1_fixed_group = MoleculeGroup(fixed_group)
stage2_fixed_group = MoleculeGroup(fixed_group)
stage1_fixed_group.add(ligand_mol)
stage2_fixed_group.remove(ligand_mol)
mobile_group = MoleculeGroup("mobile_group")
if MGName("mobile_solvents") in system.mgNames():
mobile_group.add(system[MGName("mobile_solvents")])
stage1_mobile_group = MoleculeGroup(mobile_group)
stage2_mobile_group = MoleculeGroup(mobile_group)
# now find water molecules from the water system that can be substituted for the ligand
watermols = findOverlappingWaters(ligand_mol, watersys)
stage2_mobile_group.add(watermols)
print("The number of stage 1 fixed non-solvent molecules is %d." %
stage1_fixed_group.nMolecules())
print("The number of stage 1 mobile solvent molecules is %d." %
stage1_mobile_group.nMolecules())
print("The number of stage 2 fixed non-solvent molecules is %d." %
stage2_fixed_group.nMolecules())
print("The number of stage 2 mobile solvent molecules is %d." %
stage2_mobile_group.nMolecules())
# write a PDB of all of the fixed molecules
PDB().write(stage1_mobile_group, "stage1_mobile_atoms.pdb")
PDB().write(stage2_mobile_group, "stage2_mobile_atoms.pdb")
PDB().write(stage1_fixed_group, "stage1_fixed_atoms.pdb")
PDB().write(stage2_fixed_group, "stage2_fixed_atoms.pdb")
# create the forcefields
if use_fast_ff.val:
stage1_ff = InterFF("ff")
stage2_ff = InterFF("ff")
stage1_ff.setCLJFunction(
CLJShiftFunction(Cartesian(), coul_cutoff.val, lj_cutoff.val))
stage2_ff.setCLJFunction(
CLJShiftFunction(Cartesian(), coul_cutoff.val, lj_cutoff.val))
if disable_grid.val:
stage1_ff.disableGrid()
stage2_ff.disableGrid()
else:
stage1_ff.enableGrid()
stage1_ff.setGridSpacing(grid_spacing.val)
stage1_ff.setGridBuffer(grid_buffer.val)
stage2_ff.enableGrid()
stage2_ff.setGridSpacing(grid_spacing.val)
stage2_ff.setGridBuffer(grid_buffer.val)
stage1_ff.add(stage1_mobile_group)
stage1_ff.setFixedAtoms(stage1_fixed_group.molecules())
stage2_ff.add(stage2_mobile_group)
stage2_ff.setFixedAtoms(stage2_fixed_group.molecules())
stage1.add(stage1_ff)
stage1.setComponent(stage1.totalComponent(),
stage1_ff.components().total())
stage2.add(stage1_ff)
stage2.setComponent(stage2.totalComponent(),
stage2_ff.components().total())
else:
# forcefield holding the energy between the mobile atoms and
# the fixed atoms
if disable_grid.val:
stage1_mobile_fixed = InterGroupCLJFF("mobile-fixed")
stage1_mobile_fixed = setCLJProperties(stage1_mobile_fixed)
stage1_mobile_fixed = setFakeGridProperties(stage1_mobile_fixed)
stage1_mobile_fixed.add(stage1_mobile_group, MGIdx(0))
stage1_mobile_fixed.add(stage1_fixed_group, MGIdx(1))
stage2_mobile_fixed = InterGroupCLJFF("mobile-fixed")
stage2_mobile_fixed = setCLJProperties(stage2_mobile_fixed)
stage2_mobile_fixed = setFakeGridProperties(stage2_mobile_fixed)
stage2_mobile_fixed.add(stage2_mobile_group, MGIdx(0))
stage2_mobile_fixed.add(stage2_fixed_group, MGIdx(1))
else:
stage1_mobile_fixed = GridFF2("mobile-fixed")
stage1_mobile_fixed = setCLJProperties(stage1_mobile_fixed)
stage1_mobile_fixed = setGridProperties(stage1_mobile_fixed)
stage1_mobile_fixed.add(stage1_mobile_group, MGIdx(0))
stage1_mobile_fixed.addFixedAtoms(stage1_fixed_group)
stage2_mobile_fixed = GridFF2("mobile-fixed")
stage2_mobile_fixed = setCLJProperties(stage2_mobile_fixed)
stage2_mobile_fixed = setGridProperties(stage2_mobile_fixed)
stage2_mobile_fixed.add(stage2_mobile_group, MGIdx(0))
stage2_mobile_fixed.addFixedAtoms(stage2_fixed_group)
# forcefield holding the energy between fixed atoms
stage1_mobile_mobile = InterCLJFF("mobile-mobile")
stage1_mobile_mobile = setCLJProperties(stage1_mobile_mobile)
stage1_mobile_mobile.add(stage1_mobile_group)
stage2_mobile_mobile = InterCLJFF("mobile-mobile")
stage2_mobile_mobile = setCLJProperties(stage2_mobile_mobile)
stage2_mobile_mobile.add(stage2_mobile_group)
stage1.add(stage1_mobile_group)
stage1.add(stage1_mobile_fixed)
stage1.add(stage1_mobile_mobile)
stage2.add(stage2_mobile_group)
stage2.add(stage2_mobile_fixed)
stage2.add(stage2_mobile_mobile)
stage1.setComponent(
stage1.totalComponent(),
stage1_mobile_mobile.components().total() +
stage1_mobile_fixed.components().total())
stage2.setComponent(
stage2.totalComponent(),
stage2_mobile_mobile.components().total() +
stage2_mobile_fixed.components().total())
stage1.add(stage1_mobile_group)
stage2.add(stage2_mobile_group)
stage1.add("volume_map", VolMapMonitor(stage1_mobile_group), 1000)
stage2.add("volume_map", VolMapMonitor(stage2_mobile_group), 1000)
max_water_translation = 0.15 * angstroms
max_water_rotation = 15 * degrees
stage1_moves = WeightedMoves()
if stage1_mobile_group.nViews() > 0:
rb_moves = RigidBodyMC(stage1_mobile_group)
rb_moves.setMaximumTranslation(max_water_translation)
rb_moves.setMaximumRotation(max_water_rotation)
if stage1.containsProperty("reflection sphere radius"):
reflection_radius = float(
str(stage1.property("reflection sphere radius"))) * angstroms
reflection_center = stage1.property(
"reflection center").toVector()[0]
rb_moves.setReflectionSphere(reflection_center, reflection_radius)
stage1_moves.add(rb_moves, stage1_mobile_group.nViews())
stage2_moves = WeightedMoves()
if stage2_mobile_group.nViews() > 0:
rb_moves = RigidBodyMC(stage2_mobile_group)
rb_moves.setMaximumTranslation(max_water_translation)
rb_moves.setMaximumRotation(max_water_rotation)
if stage2.containsProperty("reflection sphere radius"):
reflection_radius = float(
str(stage2.property("reflection sphere radius"))) * angstroms
reflection_center = stage2.property(
"reflection center").toVector()[0]
rb_moves.setReflectionSphere(reflection_center, reflection_radius)
stage2_moves.add(rb_moves, stage2_mobile_group.nViews())
stage1_moves.setTemperature(temperature.val)
stage2_moves.setTemperature(temperature.val)
seed = random_seed.val
if seed is None:
seed = RanGenerator().randInt(100000, 1000000)
print("Using generated random number seed %d" % seed)
else:
print("Using supplied random number seed %d" % seed)
stage1_moves.setGenerator(RanGenerator(seed))
stage2_moves.setGenerator(RanGenerator(seed + 7))
return ((stage1, stage1_moves), (stage2, stage2_moves))
def createSystem():
protomsdir = "%s/Work/ProtoMS" % os.getenv("HOME")
protoms = ProtoMS("%s/protoms2" % protomsdir)
protoms.addParameterFile("%s/parameter/amber99.ff" % protomsdir)
protoms.addParameterFile("%s/parameter/solvents.ff" % protomsdir)
protoms.addParameterFile("%s/parameter/gaff.ff" % protomsdir)
protoms.addParameterFile(solute_params)
solute = PDB().readMolecule(solute_file)
solute = solute.edit().rename(solute_name).commit()
solute = protoms.parameterise(solute, ProtoMS.SOLUTE)
perturbation = solute.property("perturbations")
lam = Symbol("lambda")
lam_fwd = Symbol("lambda_{fwd}")
lam_bwd = Symbol("lambda_{bwd}")
initial = Perturbation.symbols().initial()
final = Perturbation.symbols().final()
solute = solute.edit().setProperty(
"perturbations",
perturbation.recreate((1 - lam) * initial + lam * final)).commit()
solute_fwd = solute.edit().renumber().setProperty(
"perturbations", perturbation.substitute(lam, lam_fwd)).commit()
solute_bwd = solute.edit().renumber().setProperty(
"perturbations", perturbation.substitute(lam, lam_bwd)).commit()
solvent = PDB().read(solvent_file)
tip4p = solvent.moleculeAt(0).molecule()
tip4p = tip4p.edit().rename(solvent_name).commit()
tip4p = protoms.parameterise(tip4p, ProtoMS.SOLVENT)
tip4p_chgs = tip4p.property("charge")
tip4p_ljs = tip4p.property("LJ")
for i in range(0, solvent.nMolecules()):
tip4p = solvent.moleculeAt(i).molecule()
tip4p = tip4p.edit().rename(solvent_name) \
.setProperty("charge", tip4p_chgs) \
.setProperty("LJ", tip4p_ljs) \
.commit()
solvent.update(tip4p)
system = System()
solutes = MoleculeGroup("solutes")
solutes.add(solute)
solutes.add(solute_fwd)
solutes.add(solute_bwd)
solvent = MoleculeGroup("solvent", solvent)
all = MoleculeGroup("all")
all.add(solutes)
all.add(solvent)
system.add(solutes)
system.add(solvent)
system.add(all)
solventff = InterCLJFF("solvent:solvent")
solventff.add(solvent)
solute_intraff = InternalFF("solute_intraff")
solute_intraff.add(solute)
solute_fwd_intraff = InternalFF("solute_fwd_intraff")
solute_fwd_intraff.add(solute_fwd)
solute_bwd_intraff = InternalFF("solute_bwd_intraff")
solute_bwd_intraff.add(solute_bwd)
solute_intraclj = IntraCLJFF("solute_intraclj")
solute_intraclj.add(solute)
solute_fwd_intraclj = IntraCLJFF("solute_fwd_intraclj")
solute_fwd_intraclj.add(solute_fwd)
solute_bwd_intraclj = IntraCLJFF("solute_bwd_intraclj")
solute_bwd_intraclj.add(solute_bwd)
solute_solventff = InterGroupCLJFF("solute:solvent")
solute_solventff.add(solute, MGIdx(0))
solute_solventff.add(solvent, MGIdx(1))
solute_fwd_solventff = InterGroupCLJFF("solute_fwd:solvent")
solute_fwd_solventff.add(solute_fwd, MGIdx(0))
solute_fwd_solventff.add(solvent, MGIdx(1))
solute_bwd_solventff = InterGroupCLJFF("solute_bwd:solvent")
solute_bwd_solventff.add(solute_bwd, MGIdx(0))
solute_bwd_solventff.add(solvent, MGIdx(1))
forcefields = [
solventff, solute_intraff, solute_intraclj, solute_solventff,
solute_fwd_intraff, solute_fwd_intraclj, solute_fwd_solventff,
solute_bwd_intraff, solute_bwd_intraclj, solute_bwd_solventff
]
for forcefield in forcefields:
system.add(forcefield)
xsc_line = open(solvent_file, "r").readlines()[0]
words = xsc_line.split()
#HEADER box -12.5 -12.5 -12.5 12.5 12.5 12.5
space = PeriodicBox(
Vector(float(words[2]), float(words[3]), float(words[4])),
Vector(float(words[5]), float(words[6]), float(words[7])))
system.setProperty("space", space)
system.setProperty(
"switchingFunction",
HarmonicSwitchingFunction(coulomb_cutoff, coulomb_feather, lj_cutoff,
lj_feather))
system.setProperty("combiningRules", VariantProperty(combining_rules))
e_total = system.totalComponent()
e_fwd = Symbol("E_{fwd}")
e_bwd = Symbol("E_{bwd}")
total_nrg = solventff.components().total() + \
solute_intraclj.components().total() + solute_intraff.components().total() + \
solute_solventff.components().total()
fwd_nrg = solventff.components().total() + \
solute_fwd_intraclj.components().total() + solute_fwd_intraff.components().total() + \
solute_fwd_solventff.components().total()
bwd_nrg = solventff.components().total() + \
solute_bwd_intraclj.components().total() + solute_bwd_intraff.components().total() + \
solute_bwd_solventff.components().total()
system.setComponent(e_total, total_nrg)
system.setComponent(e_fwd, fwd_nrg)
system.setComponent(e_bwd, bwd_nrg)
system.setConstant(lam, 0.0)
system.setConstant(lam_fwd, 0.0)
system.setConstant(lam_bwd, 0.0)
system.add(SpaceWrapper(Vector(0, 0, 0), all))
system.add(PerturbationConstraint(solutes))
system.add(ComponentConstraint(lam_fwd, Min(lam + delta_lambda, 1)))
system.add(ComponentConstraint(lam_bwd, Max(lam - delta_lambda, 0)))
de_fwd = Symbol("de_fwd")
de_bwd = Symbol("de_bwd")
system.setComponent(de_fwd, fwd_nrg - total_nrg)
system.setComponent(de_bwd, total_nrg - bwd_nrg)
system.add("total_energy", MonitorComponent(e_total, Average()))
system.add("de_fwd",
MonitorComponent(de_fwd, FreeEnergyAverage(temperature)))
system.add("de_bwd",
MonitorComponent(de_bwd, FreeEnergyAverage(temperature)))
system.setComponent(lam, 0.0)
print "LAMBDA=0 : Energy = %f kcal mol-1" % system.energy().to(
kcal_per_mol)
print " (%f, %f)" % (system.energy(e_fwd).to(kcal_per_mol),
system.energy(e_bwd).to(kcal_per_mol))
system.setComponent(lam, 0.5)
print "LAMBDA=0.5 : Energy = %f kcal mol-1" % system.energy().to(
kcal_per_mol)
print " (%f, %f)" % (system.energy(e_fwd).to(kcal_per_mol),
system.energy(e_bwd).to(kcal_per_mol))
system.setComponent(lam, 1.0)
print "LAMBDA=1.0 : Energy = %f kcal mol-1" % system.energy().to(
kcal_per_mol)
print " (%f, %f)" % (system.energy(e_fwd).to(kcal_per_mol),
system.energy(e_bwd).to(kcal_per_mol))
return system
swapwaters.add(center_water)
center_point = center_water.evaluate().center()
for molnum in molnums:
if molnum != center_water.number():
water = molecules[molnum].molecule()
if Vector.distance(center_point, water.evaluate().center()) < 7.5:
water = water.residue().edit().setProperty("PDB-residue-name", "SWP").commit()
swapwaters.add(water)
else:
waters.add(water)
system.add(swapwaters)
system.add(waters)
gridff = GridFF("gridff")
gridff.setCombiningRules("arithmetic")
print("Combining rules are %s" % gridff.combiningRules())
gridff.setBuffer(2 * angstrom)
gridff.setGridSpacing( 0.5 * angstrom )
gridff.setLJCutoff(lj_cutoff)
gridff.setCoulombCutoff(coul_cutoff)
gridff.setShiftElectrostatics(True)
#gridff.setUseAtomisticCutoff(True)
#gridff.setUseReactionField(True)
cljgridff = CLJGrid()
cljgridff.setCLJFunction( CLJShiftFunction(coul_cutoff,lj_cutoff) )
.setProperty("LJ", ljs) \
.commit()
cljff.add(mol)
if i > 3:
free_mols.add(mol)
else:
sync_mols.add(mol)
ms = t.elapsed()
print("Parameterised all of the water molecules (in %d ms)!" % ms)
system = System()
system.add(cljff)
print("Initial energy = %s" % system.energy())
mc = RigidBodyMC(free_mols)
sync_mc = RigidBodyMC(sync_mols)
sync_mc.setSynchronisedTranslation(True)
sync_mc.setSynchronisedRotation(True)
nodes = Cluster.getNode()
this_thread = nodes.borrowThisThread()
moves = WeightedMoves()
moves.add(mc, 2)
moves.add(sync_mc, 1)
.setProperty("connectivity", connectivity) \
.commit()
waters.update(water)
print("Constructing the forcefields...")
pol_tip4p = waters.moleculeAt(0).molecule()
waters.remove(pol_tip4p)
cljff = InterGroupCLJFF("pol_tip4p-water")
cljff.add(pol_tip4p, MGIdx(0))
cljff.add(waters, MGIdx(1))
system = System()
system.add(cljff)
print(system.energies())
polchgs = PolariseCharges(cljff[MGIdx(0)], cljff.components().coulomb(),
CoulombProbe(1*mod_electron))
system.add(polchgs)
system.add(polchgs.selfEnergyFF())
print("Applying the polarisation constraint...")
system.applyConstraints()
print(system.energies())
pol_tip4p = system[MGIdx(0)][pol_tip4p.number()].molecule()
oscillator = oscillator.edit().rename("harm1t2").commit()
protoms = ProtoMS("%s/protoms2" % protodir)
protoms.addParameterFile( "test/io/oscillators.ff" )
oscillator = protoms.parameterise(oscillator, ProtoMS.SOLUTE)
print("...parameterisation complete!")
internalff = InternalFF("InternalFF")
internalff.add( oscillator )
system = System()
system.add( internalff )
lam = Symbol("lambda")
system.setComponent(lam, 0.01)
system.setComponent(system.totalComponent(), lam * internalff.components().total())
system.add( "average energy", MonitorComponent(system.totalComponent()) )
lambda_values = [ 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9 ]
replicas = Replicas(system, len(lambda_values))
replicas.setLambdaComponent(lam)
# Load and parameterise
solute = PDB().readMolecule(solute_file)
solute = solute.edit().rename(solute_name).commit()
protoms = createProtoMS()
protoms.addParameterFile(solute_params)
solute = protoms.parameterise(solute, ProtoMS.SOLUTE)
# Putting the solute in the system
system = System()
solutemolecules = MoleculeGroup("solute", solute)
system.add(solutemolecules)
# Setting a forcefield
solute_intraff = InternalFF("solute_intraff")
solute_intraff.add(solutemolecules)
solute_intraclj = IntraCLJFF("solute_intraclj")
solute_intraclj.add(solute)
forcefields = [ solute_intraff, solute_intraclj ]
for forcefield in forcefields:
system.add(forcefield)
# Setup the Moves
#solute_intra_moves = ZMatMove(solutemolecules)
def test_ligand_moves(verbose = False):
mols = MoleculeGroup("mols")
mols.add(ligand)
oldsys = System()
newsys = System()
parsys = System()
oldsys.add(oldff)
oldsys.add(mols)
newsys.add(newff)
newsys.add(mols)
parsys.add(parff)
parsys.add(mols)
moves = InternalMove(mols)
moves.enableOptimisedMoves()
oldsys.mustNowRecalculateFromScratch()
newsys.mustNowRecalculateFromScratch()
parsys.mustNowRecalculateFromScratch()
if verbose:
print("\nChecking total system energies...")
_checkEnergies(oldsys, newsys, parsys, verbose)
if verbose:
print("\nChecking system simulation...")
moves.setGenerator( RanGenerator(42) )
moves.clearStatistics()
t.start()
moves.move(oldsys, nmoves, False)
oldns = t.nsecsElapsed()
old_naccept = moves.nAccepted()
old_nreject = moves.nRejected()
moves.setGenerator( RanGenerator(42) )
moves.clearStatistics()
t.start()
moves.move(newsys, nmoves, False)
newns = t.nsecsElapsed()
new_naccept = moves.nAccepted()
new_nreject = moves.nRejected()
moves.setGenerator( RanGenerator(42) )
moves.clearStatistics()
t.start()
moves.move(parsys, nmoves, False)
parns = t.nsecsElapsed()
par_naccept = moves.nAccepted()
par_nreject = moves.nRejected()
if verbose:
print("OLD: accept = %s, reject = %s, time = %s ms" % \
(old_naccept, old_nreject, oldns*0.000001))
print("NEW: accept = %s, reject = %s, time = %s ms" % \
(new_naccept, new_nreject, newns*0.000001))
print("PAR: accept = %s, reject = %s, time = %s ms" % \
(par_naccept, par_nreject, parns*0.000001))
print("\nChecking final total energies...")
_checkEnergies(oldsys, newsys, parsys, verbose)
if verbose:
print("\nRechecking total energies...")
oldsys.mustNowRecalculateFromScratch()
newsys.mustNowRecalculateFromScratch()
parsys.mustNowRecalculateFromScratch()
_checkEnergies(oldsys, newsys, parsys, verbose)
def test_grid_sim(verbose = False):
oldsys = System()
newsys = System()
oldsys.add(cluster)
oldsys.add(old_clusterff)
oldsys.add(old_fixedff)
newsys.add(cluster)
newsys.add(new_clusterff)
t = QElapsedTimer()
t.start()
old_total = oldsys.energy().value()
oldns = t.nsecsElapsed()
t.start()
new_total = newsys.energy().value()
newns = t.nsecsElapsed()
ff = newsys[FFName("new_clusterff")]
print(ff.grid())
old_cnrg = oldsys.energy( old_clusterff.components().coulomb() ).value() + \
oldsys.energy( old_fixedff.components().coulomb() ).value()
old_ljnrg = oldsys.energy( old_clusterff.components().lj() ).value() + \
oldsys.energy( old_fixedff.components().lj() ).value()
new_cnrg = newsys.energy( new_clusterff.components().coulomb() ).value()
new_ljnrg = newsys.energy( new_clusterff.components().lj() ).value()
if verbose:
print("OLD: %s %s %s %s : %s ms" % (old_total,old_cnrg+old_ljnrg,old_cnrg,old_ljnrg,
0.000001*oldns))
print("NEW: %s %s %s %s : %s ms" % (new_total,new_cnrg+new_ljnrg,new_cnrg,new_ljnrg,
0.000001*newns))
moves = RigidBodyMC(cluster)
moves.enableOptimisedMoves()
moves.setReflectionSphere( reflect_sphere_center, reflect_sphere_radius )
moves.setGenerator( RanGenerator( 42 ) )
t.start()
moves.move(oldsys, 1000, False)
move_oldns = t.nsecsElapsed()
moves.setGenerator( RanGenerator( 42 ) )
t.start()
moves.move(newsys, 1000, False)
move_newns = t.nsecsElapsed()
t.start()
old_total = oldsys.energy().value()
old_ns = t.nsecsElapsed()
t.start()
new_total = newsys.energy().value()
new_ns = t.nsecsElapsed()
old_cnrg = oldsys.energy( old_clusterff.components().coulomb() ).value() + \
oldsys.energy( old_fixedff.components().coulomb() ).value()
old_ljnrg = oldsys.energy( old_clusterff.components().lj() ).value() + \
oldsys.energy( old_fixedff.components().lj() ).value()
new_cnrg = newsys.energy( new_clusterff.components().coulomb() ).value()
new_ljnrg = newsys.energy( new_clusterff.components().lj() ).value()
if verbose:
print("\nMoves: %s ms vs. %s ms" % (0.000001*move_oldns, 0.000001*move_newns))
print("OLD SYS: %s %s %s %s : %s ms" % (old_total,old_cnrg+old_ljnrg,old_cnrg,old_ljnrg,
0.000001*old_ns))
print("NEW SYS: %s %s %s %s : %s ms" % (new_total,new_cnrg+new_ljnrg,new_cnrg,new_ljnrg,
0.000001*new_ns))
newsys.mustNowRecalculateFromScratch()
oldsys.mustNowRecalculateFromScratch()
t.start()
old_total = oldsys.energy().value()
old_ns = t.nsecsElapsed()
t.start()
new_total = newsys.energy().value()
new_ns = t.nsecsElapsed()
old_cnrg = oldsys.energy( old_clusterff.components().coulomb() ).value() + \
oldsys.energy( old_fixedff.components().coulomb() ).value()
old_ljnrg = oldsys.energy( old_clusterff.components().lj() ).value() + \
oldsys.energy( old_fixedff.components().lj() ).value()
new_cnrg = newsys.energy( new_clusterff.components().coulomb() ).value()
new_ljnrg = newsys.energy( new_clusterff.components().lj() ).value()
if verbose:
print("\nRecalculate energy")
print("OLD SYS: %s %s %s %s : %s ms" % (old_total,old_cnrg+old_ljnrg,old_cnrg,old_ljnrg,
0.000001*old_ns))
print("NEW SYS: %s %s %s %s : %s ms" % (new_total,new_cnrg+new_ljnrg,new_cnrg,new_ljnrg,
0.000001*new_ns))
def test_system(verbose=False):
cljff = InterCLJFF()
mincoords = Vector(-18.3854, -18.66855, -18.4445)
maxcoords = Vector( 18.3854, 18.66855, 18.4445)
vol = PeriodicBox(mincoords, maxcoords)
cljff.setSpace(vol)
mols = PDB().read("../io/water.pdb")
if verbose:
print("Read in %d molecules!" % mols.nMolecules())
i = 0
mol = mols.moleculeAt(0).molecule()
mol = mol.edit().atom( AtomName("O00") ) \
.setProperty("LJ", LJParameter(3.15363*angstrom, \
0.1550*kcal_per_mol)).molecule() \
.atom( AtomName("H01") ) \
.setProperty("charge", 0.520 * mod_electron).molecule() \
.atom( AtomName("H02") ) \
.setProperty("charge", 0.520 * mod_electron).molecule() \
.atom( AtomName("M03") ) \
.setProperty("charge", -1.04 * mod_electron).molecule() \
.commit()
charges = mol.property("charge")
ljs = mol.property("LJ")
cljff.add(mol)
for i in range(1, mols.nMolecules()):
mol = mols.moleculeAt(i).molecule()
mol = mol.edit().setProperty("charge", charges) \
.setProperty("LJ", ljs) \
.commit()
cljff.add(mol)
system = System()
system.add(cljff)
nrg = system.energy()
if verbose:
print("System energy = %s" % (nrg))
copy_system = System(system)
nrg2 = copy_system.energy()
if verbose:
print("Copy energy: %s (should be %s)" % (nrg2,nrg))
assert_almost_equal(nrg.value(), nrg2.value(), 5)
copy_system.mustNowRecalculateFromScratch()
nrg3 = copy_system.energy()
if verbose:
print("Copy energy: %s (should be %s)" % (nrg2,nrg))
assert_almost_equal(nrg.value(), nrg3.value(), 5)
def test_protein_moves(verbose = False):
mols = MoleculeGroup("mols")
for residue in protein.residues():
mols.add(residue)
oldsys = System()
newsys = System()
parsys = System()
oldsys.add(oldff)
oldsys.add(mols)
newsys.add(newff)
newsys.add(mols)
parsys.add(parff)
parsys.add(mols)
moves = RigidBodyMC(mols)
moves.setMaximumTranslation(0.25 * angstrom)
moves.setMaximumRotation(1 * degrees)
moves.enableOptimisedMoves()
oldsys.mustNowRecalculateFromScratch()
newsys.mustNowRecalculateFromScratch()
parsys.mustNowRecalculateFromScratch()
if verbose:
print("\nChecking total system energies...")
_checkEnergies(oldsys, newsys, parsys, verbose)
if verbose:
print("\nChecking system simulation...")
moves.setGenerator( RanGenerator(42) )
moves.clearStatistics()
t.start()
moves.move(oldsys, nmoves, False)
oldns = t.nsecsElapsed()
old_naccept = moves.nAccepted()
old_nreject = moves.nRejected()
moves.setGenerator( RanGenerator(42) )
moves.clearStatistics()
t.start()
moves.move(newsys, nmoves, False)
newns = t.nsecsElapsed()
new_naccept = moves.nAccepted()
new_nreject = moves.nRejected()
moves.setGenerator( RanGenerator(42) )
moves.clearStatistics()
t.start()
moves.move(parsys, nmoves, False)
parns = t.nsecsElapsed()
par_naccept = moves.nAccepted()
par_nreject = moves.nRejected()
if verbose:
print("OLD: accept = %s, reject = %s, time = %s ms" % \
(old_naccept, old_nreject, oldns*0.000001))
print("NEW: accept = %s, reject = %s, time = %s ms" % \
(new_naccept, new_nreject, newns*0.000001))
print("PAR: accept = %s, reject = %s, time = %s ms" % \
(par_naccept, par_nreject, parns*0.000001))
print("\nChecking final total energies...")
_checkEnergies(oldsys, newsys, parsys, verbose)
if verbose:
print("\nRechecking total energies...")
oldsys.mustNowRecalculateFromScratch()
newsys.mustNowRecalculateFromScratch()
parsys.mustNowRecalculateFromScratch()
_checkEnergies(oldsys, newsys, parsys, verbose)
cljff.add(mol)
ms = t.elapsed()
print("Parameterised all of the water molecules (in %d ms)!" % ms)
system = System()
rdf = RDFMonitor(0 * angstrom, 10 * angstrom, 0.05 * angstrom)
rdf.add(MolIdx(0) + AtomName("O00"), AtomName("O00"))
rdf2 = RDFMonitor(0 * angstrom, 10 * angstrom, 0.05 * angstrom)
rdf2.add(MolIdx(0) + AtomName("O00"), AtomName("H01"))
rdf2.add(MolIdx(0) + AtomName("O00"), AtomName("H02"))
system.add(cljff)
system.add("O-O RDF", rdf)
system.add("O-H RDF", rdf2)
t.start()
system.collectStats()
ms = t.elapsed()
print("Collecting stats took %d ms" % ms)
rdf = system.monitor(MonitorName("O-O RDF"))
print("\nO-O RDF")
for i in range(0, rdf.nBins()):
def test_props(verbose=False):
sys = System()
box0 = PeriodicBox( Vector(10.0,10.0,10.0) )
box1 = PeriodicBox( Vector(20.0,20.0,20.0) )
if verbose:
print(box0)
print(box0.volume())
print(box1.volume())
assert(not sys.containsProperty("space"))
sys.add( InterCLJFF("cljff") )
if verbose:
print(sys)
print(sys.property("space"))
print(sys.userProperties().propertyKeys())
print(sys.builtinProperties().propertyKeys())
assert(sys.containsProperty("space"))
assert_equal( sys.property("space"), Cartesian() )
sys.setProperty( "space0", LinkToProperty("space", FFIdx(0)) )
if verbose:
print(sys.property("space0"))
assert(sys.containsProperty("space0"))
sys.setProperty("space0", box0)
if verbose:
print(sys.property("space"))
assert_equal(sys.property("space0"), box0)
sys.setProperty("space1", box1)
sys.setProperty("combined_space", CombineSpaces("space0", "space1"))
assert_equal(sys.property("space1"), box1)
if verbose:
print(sys.properties().propertyKeys())
print(sys.property("combined_space"))
print(sys.property("combined_space").volume())
assert_almost_equal( sys.property("combined_space").volume().value(),
sys.property("space0").volume().value() + sys.property("space1").volume().value(), 5 )
space3 = PeriodicBox( Vector(5,5,5) )
sys.setProperty("space0", space3)
assert_equal( sys.property("space0"), space3 )
if verbose:
print(sys.property("combined_space"))
print(sys.property("combined_space").volume())
assert_almost_equal( sys.property("combined_space").volume().value(),
sys.property("space0").volume().value() + sys.property("space1").volume().value(), 5 )
sys.removeProperty("space0")
if verbose:
print(sys.properties().propertyKeys())
assert( not sys.containsProperty("space0") )
titrator = Titrator()
titrator.setPositiveTemplate(sodium)
titrator.setNegativeTemplate(chloride)
titrator.setNeutralTemplate(water)
system = System()
cljff = InterCLJFF("cljff")
cljff.add(molecules)
solvent = MoleculeGroup("solvent")
solvent.add(molecules)
titrator.setMoleculeGroup(solvent)
system.add(cljff)
system.add(solvent)
system.setProperty("space", space)
print("Initialising the ions...")
titrator.applyTo(system)
print("Randomising the location of ions...")
titrator.randomiseCharge(3)
titrator.applyTo(system)
print("System is ready for simulation :-)")
PDB().write(system.molecules(), "test0000.pdb")
move = TitrationMove()
move.setTemperature(25 * celsius)
def createSystemFrom(molecules,
space,
system_name,
naming_scheme=NamingScheme()):
"""Create a new System from the passed molecules and space,
sorting the molecules into different molecule groups based on the
passed naming scheme"""
system = System(system_name)
# If requested, change the water model for all water molecules
if water_model.val == "tip4p":
molnums = molecules.molNums()
new_molecules = Molecules()
print("Forcing all water molecules to use the %s water model..." %
water_model.val)
print("Converting %d molecules..." % len(molnums))
i = 0
for molnum in molnums:
molecule = molecules[molnum].molecule()
if i % 100 == 0:
print("%d" % i)
sys.stdout.flush()
elif i % 10 == 0:
print(".", end=' ')
sys.stdout.flush()
i += 1
if molecule.nAtoms() == 3:
# this could be a TIP3P water
resname = str(molecule.residue().name().value()).lower()
if resname == "wat" or resname == "t3p":
new_molecule = convertTip3PtoTip4P(molecule)
if new_molecule:
molecule = new_molecule
new_molecules.add(molecule)
print("%d" % i)
molecules = new_molecules
nmols = molecules.nMolecules()
print("Number of molecules == %s" % nmols)
print("System space == %s" % space)
if nmols == 0:
return system
print("Assigning molecules to molecule groups...")
solute_group = MoleculeGroup(naming_scheme.solutesGroupName().value())
protein_group = MoleculeGroup(naming_scheme.proteinsGroupName().value())
solvent_group = MoleculeGroup(naming_scheme.solventsGroupName().value())
water_group = MoleculeGroup(naming_scheme.watersGroupName().value())
ion_group = MoleculeGroup(naming_scheme.ionsGroupName().value())
all_group = MoleculeGroup(naming_scheme.allMoleculesGroupName().value())
# The all molecules group has all of the molecules
all_group.add(molecules)
system.add(all_group)
# Run through each molecule and decide what type it is...
molnums = molecules.molNums()
molnums.sort()
central_molecule = None
solutes = []
proteins = []
solvents = []
waters = []
ions = []
for molnum in molnums:
molecule = molecules[molnum].molecule()
resnams = getResidueNames(molecule)
if naming_scheme.isSolute(resnams):
solutes.append(molecule)
elif naming_scheme.isProtein(resnams):
proteins.append(molecule)
elif naming_scheme.isWater(resnams):
waters.append(molecule)
elif naming_scheme.isIon(resnams):
ions.append(molecule)
elif molecule.nResidues() == 1:
solvents.append(molecule)
else:
solutes.append(molecule)
# Ok - we have now divided everything up into groups
for solute in solutes:
solute_group.add(solute)
for protein in proteins:
protein_group.add(protein)
for water in waters:
solvent_group.add(water)
water_group.add(water)
for solvent in solvents:
solvent_group.add(solvent)
for ion in ions:
solvent_group.add(ion)
ion_group.add(ion)
if solute_group.nMolecules() > 0:
system.add(solute_group)
if protein_group.nMolecules() > 0:
system.add(protein_group)
if solvent_group.nMolecules() > 0:
system.add(solvent_group)
if water_group.nMolecules() > 0:
system.add(water_group)
if ion_group.nMolecules() > 0:
system.add(ion_group)
print("Number of solute molecules == %s" % solute_group.nMolecules())
print("Number of protein molecules == %s" % protein_group.nMolecules())
print("Number of ions == %s" % ion_group.nMolecules())
print("Number of water molecules == %s" % water_group.nMolecules())
print("Number of solvent molecules == %s" % solvent_group.nMolecules())
print(
"(solvent group is waters + ions + unidentified single-residue molecules)"
)
system.setProperty("space", space)
system.add(SpaceWrapper(Vector(0), all_group))
system.applyConstraints()
print("Returning the constructed system")
return system
