def write(self, inputdir, outputdir):
""" Writes the production protocol and files into a folder.
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a equilibration process.
outputdir : str
Directory where to write the production setup files.
"""
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits, 'timesteps', self.runtime, timestep=self.acemd.timestep)
self.acemd.temperature = str(self.temperature)
self.acemd.langevintemp = str(self.temperature)
if self.fb_k > 0: #use TCL only for flatbottom
mol = Molecule(os.path.join(inputdir, self.acemd.coordinates))
self.acemd.tclforces = 'on'
tcl = list(self.acemd.TCL)
tcl[0] = tcl[0].format(NUMSTEPS=numsteps, KCONST=self.fb_k,
REFINDEX=' '.join(map(str, mol.get('index', self.fb_reference))),
SELINDEX=' '.join(map(str, mol.get('index', self.fb_selection))),
BOX=' '.join(map(str, self.fb_box)))
self.acemd.TCL = tcl[0] + tcl[1]
else:
self.acemd.TCL = 'set numsteps {}\n'.format(numsteps)
self.acemd.setup(inputdir, outputdir, overwrite=True)
def write(self, inputdir, outputdir):
""" Writes the production protocol and files into a folder.
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a equilibration process.
outputdir : str
Directory where to write the production setup files.
"""
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits,
'timesteps',
self.runtime,
timestep=self.acemd.timestep)
self.acemd.temperature = self.temperature
self.acemd.langevintemp = self.temperature
self.acemd.thermostattemp = self.temperature
self.acemd.run = str(numsteps)
self.acemd.restraints = self.restraints
if self.adaptive:
self.acemd.binvelocities = None
self.acemd.setup(inputdir, outputdir, overwrite=True)
def test_acemd3(self):
from htmd.util import tempname
from htmd.home import home
from htmd.units import convert
from glob import glob
import os
from htmd.mdengine.acemd.acemd import GroupRestraint
eq = Equilibration()
eq.runtime = 4
eq.timeunits = "ns"
eq.temperature = 300
eq.restraintsteps = convert(
eq.timeunits, "timesteps", eq.runtime, timestep=eq.acemd.timestep
)
ligres = GroupRestraint(
"resname MOL and noh",
[42, 38, 1],
[(5, 0)],
fbcentre=[-0.178, -0.178, 29.195],
)
eq.restraints = eq.defaultEquilRestraints(1000000) + [ligres]
tmpdir = tempname()
eq.write(
home(dataDir=os.path.join("test-protocols", "build", "protLig")), tmpdir
)
# Compare with reference
refdir = home(
dataDir=os.path.join(
"test-protocols", "equilibration", "acemd3", "protLig", "prerun"
)
)
files = [os.path.basename(f) for f in glob(os.path.join(refdir, "*"))]
self._compareResultFolders(refdir, tmpdir, "protLig")
def write(self, inputdir, outputdir):
""" Writes the production protocol and files into a folder.
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a equilibration process.
outputdir : str
Directory where to write the production setup files.
"""
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits, 'timesteps', self.runtime, timestep=self.acemd.timestep)
self.acemd.temperature = str(self.temperature)
self.acemd.langevintemp = str(self.temperature)
if self.fb_k > 0: #use TCL only for flatbottom
mol = Molecule(os.path.join(inputdir, self.acemd.coordinates))
self.acemd.tclforces = 'on'
tcl = list(self.acemd.TCL)
tcl[0] = tcl[0].format(NUMSTEPS=numsteps, KCONST=self.fb_k,
REFINDEX=' '.join(map(str, mol.get('index', self.fb_reference))),
SELINDEX=' '.join(map(str, mol.get('index', self.fb_selection))),
BOX=' '.join(map(str, self.fb_box)))
self.acemd.TCL = tcl[0] + tcl[1]
else:
self.acemd.TCL = 'set numsteps {}\n'.format(numsteps)
self.acemd.setup(inputdir, outputdir, overwrite=True)
def write(self, inputdir, outputdir):
""" Write the equilibration protocol
Writes the equilibration protocol and files into a folder for execution
using files inside the inputdir directory
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a build process.
outputdir : str
Directory where to write the equilibration setup files.
Examples
--------
>>> md = Equilibration()
>>> md.write('./build','./equil')
"""
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits, 'timesteps', self.runtime, timestep=self.acemd.timestep)
pdbfile = os.path.join(inputdir, self.acemd.coordinates)
inmol = Molecule(pdbfile)
if self.constraintsteps is None:
constrsteps = int(numsteps / 2)
else:
constrsteps = int(self.constraintsteps)
tcl = list(self.acemd.TCL)
tcl[0] = tcl[0].format(NUMSTEPS=numsteps, KCONST=self.fb_k,
REFINDEX=' '.join(map(str, inmol.get('index', self.fb_reference))),
SELINDEX=' '.join(map(str, inmol.get('index', self.fb_selection))),
BOX=' '.join(map(str, self.fb_box)),
NVTSTEPS=self.nvtsteps, CONSTRAINTSTEPS=constrsteps, TEMPERATURE=self.temperature)
self.acemd.TCL = tcl[0] + tcl[1]
if self.acemd.celldimension is None and self.acemd.extendedsystem is None:
coords = inmol.get('coords', sel='water')
if coords.size == 0: # It's a vacuum simulation
coords = inmol.get('coords', sel='all')
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
dim = dim + 12.
else:
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
self.acemd.celldimension = '{} {} {}'.format(dim[0], dim[1], dim[2])
if self.useconstantratio:
self.acemd.useconstantratio = 'on'
self.acemd.setup(inputdir, outputdir, overwrite=True)
# Adding constraints
inmol.set('occupancy', 0)
inmol.set('beta', 0)
for sel in self.constraints:
inmol.set('beta', self.constraints[sel], sel)
outfile = os.path.join(outputdir, self.acemd.coordinates)
inmol.write(outfile)
def test_acemd3(self):
from htmd.util import tempname
from htmd.home import home
from glob import glob
import os
eq = Equilibration(_version=3)
eq.runtime = 4
eq.timeunits = 'ns'
eq.temperature = 300
# keep protein on the same place during all equilibration
from htmd.units import convert
eq.constraintsteps = convert(eq.timeunits,
'timesteps',
eq.runtime,
timestep=eq.acemd.timestep)
eq.constraints = {
'protein and name CA': 1,
'protein and noh and not name CA': 0.1
}
eq.fb_reference = 'protein and name CA'
eq.fb_selection = 'resname MOL and noh'
eq.fb_box = [-21, 21, -19, 19, 29, 30]
eq.fb_k = 5
tmpdir = tempname()
eq.write(
home(dataDir=os.path.join('test-protocols', 'build', 'protLig')),
tmpdir)
# Compare with reference
refdir = home(dataDir=os.path.join('test-protocols', 'equilibration',
'acemd3', 'protLig', 'prerun'))
files = [os.path.basename(f) for f in glob(os.path.join(refdir, '*'))]
self._compareResultFolders(refdir, tmpdir, 'protLig')
def write(self, inputdir, outputdir):
""" Write the equilibration protocol
Writes the equilibration protocol and files into a folder for execution
using files inside the inputdir directory
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a build process.
outputdir : str
Directory where to write the equilibration setup files.
Examples
--------
>>> md = Equilibration()
>>> md.write('./build','./equil')
"""
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits, 'timesteps', self.runtime, timestep=self.acemd.timestep)
self.acemd.temperature = self.temperature
self.acemd.thermostattemp = self.temperature
self.acemd.run = str(numsteps)
if self.constraintsteps is None:
constrsteps = int(numsteps / 2)
else:
constrsteps = int(self.constraintsteps)
# Adding the default restraints of the equilibration
restraints = list()
restraints.append(AtomRestraint('protein and noh and not name CA', 0, [(0.1, 0), (0, constrsteps)]))
restraints.append(AtomRestraint('protein and name CA', 0, [(1, 0), (0, constrsteps)]))
if self.restraints is not None:
restraints += self.restraints
self.acemd.restraints = restraints
if self.acemd.celldimension is None and self.acemd.extendedsystem is None:
inmol = Molecule(os.path.join(inputdir, self.acemd.coordinates))
coords = inmol.get('coords', sel='water')
if coords.size == 0: # It's a vacuum simulation
coords = inmol.get('coords', sel='all')
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
dim = dim + 12.
else:
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
self.acemd.celldimension = '{} {} {}'.format(dim[0], dim[1], dim[2])
if self.useconstantratio:
self.acemd.useconstantratio = 'on'
self.acemd.setup(inputdir, outputdir, overwrite=True)
def write(self, inputdir, outputdir):
""" Writes the production protocol and files into a folder.
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a equilibration process.
outputdir : str
Directory where to write the production setup files.
"""
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits, 'timesteps', self.runtime, timestep=self.acemd.timestep)
self.acemd.temperature = str(self.temperature)
self.acemd.langevintemp = str(self.temperature)
if self.fb_k > 0: #use TCL only for flatbottom
mol = Molecule(os.path.join(inputdir, self.acemd.coordinates))
self.acemd.tclforces = 'on'
tcl = list(self.acemd.TCL)
tcl[0] = tcl[0].format(NUMSTEPS=numsteps, KCONST=self.fb_k,
REFINDEX=' '.join(map(str, mol.get('index', self.fb_reference))),
SELINDEX=' '.join(map(str, mol.get('index', self.fb_selection))),
BOX=' '.join(map(str, self.fb_box)))
self.acemd.TCL = tcl[0] + tcl[1]
else:
self.acemd.TCL = 'set numsteps {}\n'.format(numsteps)
if self.useconstraints:
# Turn on constraints
self.acemd.constraints = 'on'
self.acemd.constraintscaling = '1.0'
else:
if len(self.constraints) != 0:
logger.warning('You have setup constraints to {} but constraints are turned off. '
'If you want to use constraints, define useconstraints=True'.format(self.constraints))
self.acemd.setup(inputdir, outputdir, overwrite=True)
# Adding constraints
if self.useconstraints:
inmol = Molecule(os.path.join(inputdir, self.acemd.coordinates))
inmol.set('occupancy', 0)
inmol.set('beta', 0)
if len(self.constraints) == 0:
raise RuntimeError('You have set the production to use constraints (useconstraints=True), but have not '
'defined any constraints (constraints={}).')
else:
for sel in self.constraints:
inmol.set('beta', self.constraints[sel], sel)
outfile = os.path.join(outputdir, self.acemd.coordinates)
inmol.write(outfile)
self.acemd.consref = self.acemd.coordinates
def write(self, inputdir, outputdir):
""" Writes the production protocol and files into a folder.
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a equilibration process.
outputdir : str
Directory where to write the production setup files.
"""
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits, 'timesteps', self.runtime, timestep=self.acemd.timestep)
self.acemd.temperature = str(self.temperature)
self.acemd.langevintemp = str(self.temperature)
if self.fb_k > 0: #use TCL only for flatbottom
mol = Molecule(os.path.join(inputdir, self.acemd.coordinates))
self.acemd.tclforces = 'on'
tcl = list(self.acemd.TCL)
tcl[0] = tcl[0].format(NUMSTEPS=numsteps, KCONST=self.fb_k,
REFINDEX=' '.join(map(str, mol.get('index', self.fb_reference))),
SELINDEX=' '.join(map(str, mol.get('index', self.fb_selection))),
BOX=' '.join(map(str, self.fb_box)))
self.acemd.TCL = tcl[0] + tcl[1]
else:
self.acemd.TCL = 'set numsteps {}\n'.format(numsteps)
if self.useconstraints:
# Turn on constraints
self.acemd.constraints = 'on'
self.acemd.constraintscaling = '1.0'
else:
if len(self.constraints) != 0:
logger.warning('You have setup constraints to {} but constraints are turned off. '
'If you want to use constraints, define useconstraints=True'.format(self.constraints))
self.acemd.setup(inputdir, outputdir, overwrite=True)
# Adding constraints
if self.useconstraints:
inmol = Molecule(os.path.join(inputdir, self.acemd.coordinates))
inmol.set('occupancy', 0)
inmol.set('beta', 0)
if len(self.constraints) == 0:
raise RuntimeError('You have set the production to use constraints (useconstraints=True), but have not '
'defined any constraints (constraints={}).')
else:
for sel in self.constraints:
inmol.set('beta', self.constraints[sel], sel)
outfile = os.path.join(outputdir, self.acemd.coordinates)
inmol.write(outfile)
self.acemd.consref = self.acemd.coordinates
def write(self, inputdir, outputdir):
""" Writes the production protocol and files into a folder.
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a equilibration process.
outputdir : str
Directory where to write the production setup files.
"""
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits, 'timesteps', self.runtime, timestep=self.acemd.timestep)
self.acemd.temperature = self.temperature
self.acemd.thermostattemp = self.temperature
self.acemd.run = str(numsteps)
self.acemd.restraints = self.restraints
if self.adaptive:
self.acemd.binvelocities = None
self.acemd.setup(inputdir, outputdir, overwrite=True)
def write(self, inputdir, outputdir):
""" Write the equilibration protocol
Writes the equilibration protocol and files into a folder for execution
using files inside the inputdir directory
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a build process.
outputdir : str
Directory where to write the equilibration setup files.
Examples
--------
>>> md = Equilibration()
>>> md.write('./build','./equil')
"""
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits, 'timesteps', self.runtime, timestep=self.acemd.timestep)
pdbfile = os.path.join(inputdir, self.acemd.coordinates)
inmol = Molecule(pdbfile)
if np.any(inmol.atomselect('lipids')) and not self.useconstantratio:
logger.warning('Lipids detected in input structure. We highly recommend setting useconstantratio=True '
'for membrane simulations.')
if self.constraintsteps is None:
constrsteps = int(numsteps / 2)
else:
constrsteps = int(self.constraintsteps)
if isinstance(self.acemd.TCL, tuple):
tcl = list(self.acemd.TCL)
tcl[0] = tcl[0].format(NUMSTEPS=numsteps, KCONST=self.fb_k,
REFINDEX=' '.join(map(str, inmol.get('index', self.fb_reference))),
SELINDEX=' '.join(map(str, inmol.get('index', self.fb_selection))),
BOX=' '.join(map(str, self.fb_box)),
NVTSTEPS=self.nvtsteps, CONSTRAINTSTEPS=constrsteps, TEMPERATURE=self.temperature)
self.acemd.TCL = tcl[0] + tcl[1]
else:
logger.warning('{} default TCL was already formatted.'.format(self.__class__.__name__))
if self.acemd.celldimension is None and self.acemd.extendedsystem is None:
coords = inmol.get('coords', sel='water')
if coords.size == 0: # It's a vacuum simulation
coords = inmol.get('coords', sel='all')
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
dim = dim + 12.
else:
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
self.acemd.celldimension = '{} {} {}'.format(dim[0], dim[1], dim[2])
if self.useconstantratio:
self.acemd.useconstantratio = 'on'
self.acemd.setup(inputdir, outputdir, overwrite=True)
# Adding constraints by writing them to the consref file
inconsreffile = os.path.join(inputdir, self.acemd.consref)
consrefmol = Molecule(inconsreffile)
consrefmol.set('occupancy', 0)
consrefmol.set('beta', 0)
if len(self.constraints) == 0:
raise RuntimeError('You have not defined any constraints for the Equilibration (constraints={}).')
else:
for sel in self.constraints:
consrefmol.set('beta', self.constraints[sel], sel)
outconsreffile = os.path.join(outputdir, self.acemd.consref)
consrefmol.write(outconsreffile)
def write(self, inputdir, outputdir):
""" Writes the production protocol and files into a folder.
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a equilibration process.
outputdir : str
Directory where to write the production setup files.
"""
self._findFiles(inputdir)
self._amberFixes()
self.acemd.temperature = self.temperature
self.acemd.langevintemp = self.temperature
from htmd.units import convert
numsteps = convert(self.timeunits, 'timesteps', self.runtime, timestep=self.acemd.timestep)
pdbfile = os.path.join(inputdir, self.acemd.coordinates)
inmol = Molecule(pdbfile)
if np.any(inmol.atomselect('lipids')) and not self.useconstantratio:
logger.warning('Lipids detected in input structure. We highly recommend setting useconstantratio=True '
'for membrane simulations.')
if self.fb_k > 0: # use TCL only for flatbottom
self.acemd.tclforces = 'on'
tcl = list(self.acemd.TCL)
tcl[0] = tcl[0].format(NUMSTEPS=numsteps, TEMPERATURE=self.temperature, KCONST=self.fb_k,
REFINDEX=' '.join(map(str, inmol.get('index', self.fb_reference))),
SELINDEX=' '.join(map(str, inmol.get('index', self.fb_selection))),
BOX=' '.join(map(str, self.fb_box)))
self.acemd.TCL = tcl[0] + tcl[1]
else:
self.acemd.TCL = 'set numsteps {NUMSTEPS}\n' \
'set temperature {TEMPERATURE}\n'.format(NUMSTEPS=numsteps, TEMPERATURE=self.temperature)
if self.useconstraints:
# Turn on constraints
self.acemd.constraints = 'on'
self.acemd.constraintscaling = 1.0
else:
if len(self.constraints) != 0:
logger.warning('You have setup constraints to {} but constraints are turned off. '
'If you want to use constraints, define useconstraints=True'.format(self.constraints))
if self.useconstantratio:
self.acemd.useconstantratio = 'on'
if self.adaptive:
self.acemd.binvelocities = None
self.acemd.setup(inputdir, outputdir, overwrite=True)
# Adding constraints by writing them to the consref file
if self.useconstraints:
inconsreffile = os.path.join(inputdir, self.acemd.consref)
consrefmol = Molecule(inconsreffile)
consrefmol.set('occupancy', 0)
consrefmol.set('beta', 0)
if len(self.constraints) == 0:
raise RuntimeError('You have set the production to use constraints (useconstraints=True), but have not '
'defined any constraints (constraints={}).')
else:
for sel in self.constraints:
consrefmol.set('beta', self.constraints[sel], sel)
outconsreffile = os.path.join(outputdir, self.acemd.consref)
consrefmol.write(outconsreffile)
if len(mismatch) != 0 or len(error) != 0 or len(match) != len(files):
raise RuntimeError(
'Different results produced by amber.build for test {} between {} and {} in files {}.'.format(pid, compare, tmpdir, mismatch))
for f in deletefiles:
os.remove(f)
# Test ACEMD version 2
eq = Equilibration(_version=2)
eq.runtime = 4
eq.timeunits = 'ns'
eq.temperature = 300
# keep protein on the same place during all equilibration
from htmd.units import convert
eq.constraintsteps = convert(eq.timeunits, 'timesteps', eq.runtime, timestep=eq.acemd.timestep)
eq.constraints = {'protein and name CA': 1, 'protein and noh and not name CA': 0.1}
eq.fb_reference = 'protein and name CA'
eq.fb_selection = 'resname MOL and noh'
eq.fb_box = [-21, 21, -19, 19, 29, 30]
eq.fb_k = 5
tmpdir = tempname()
eq.write(home(dataDir=os.path.join('test-protocols', 'build', 'protLig')), tmpdir)
# Compare with reference
refdir = home(dataDir=os.path.join('test-protocols', 'equilibration', 'acemd2', 'protLig', 'prerun'))
files = [os.path.basename(f) for f in glob(os.path.join(refdir, '*'))]
_compareResultFolders(refdir, tmpdir, 'protLig')
# Test new ACEMD version 3
def write(self, inputdir, outputdir):
""" Writes the production protocol and files into a folder.
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a equilibration process.
outputdir : str
Directory where to write the production setup files.
"""
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits,
'timesteps',
self.runtime,
timestep=self.acemd.timestep)
pdbfile = os.path.join(inputdir, self.acemd.coordinates)
inmol = Molecule(pdbfile)
if np.any(inmol.atomselect('lipids')) and not self.useconstantratio:
logger.warning(
'Lipids detected in input structure. We highly recommend setting useconstantratio=True '
'for membrane simulations.')
if self.fb_k > 0: # use TCL only for flatbottom
self.acemd.tclforces = 'on'
tcl = list(self.acemd.TCL)
tcl[0] = tcl[0].format(
NUMSTEPS=numsteps,
TEMPERATURE=self.temperature,
KCONST=self.fb_k,
REFINDEX=' '.join(
map(str, inmol.get('index', self.fb_reference))),
SELINDEX=' '.join(
map(str, inmol.get('index', self.fb_selection))),
BOX=' '.join(map(str, self.fb_box)))
self.acemd.TCL = tcl[0] + tcl[1]
else:
self.acemd.TCL = 'set numsteps {NUMSTEPS}\n' \
'set temperature {TEMPERATURE}\n'.format(NUMSTEPS=numsteps, TEMPERATURE=self.temperature)
if self.useconstraints:
# Turn on constraints
self.acemd.constraints = 'on'
self.acemd.constraintscaling = '1.0'
else:
if len(self.constraints) != 0:
logger.warning(
'You have setup constraints to {} but constraints are turned off. '
'If you want to use constraints, define useconstraints=True'
.format(self.constraints))
if self.useconstantratio:
self.acemd.useconstantratio = 'on'
if self.adaptive:
self.acemd.binvelocities = None
self.acemd.setup(inputdir, outputdir, overwrite=True)
# Adding constraints by writing them to the consref file
if self.useconstraints:
inconsreffile = os.path.join(inputdir, self.acemd.consref)
consrefmol = Molecule(inconsreffile)
consrefmol.set('occupancy', 0)
consrefmol.set('beta', 0)
if len(self.constraints) == 0:
raise RuntimeError(
'You have set the production to use constraints (useconstraints=True), but have not '
'defined any constraints (constraints={}).')
else:
for sel in self.constraints:
consrefmol.set('beta', self.constraints[sel], sel)
outconsreffile = os.path.join(outputdir, self.acemd.consref)
consrefmol.write(outconsreffile)
def write(self, inputdir, outputdir):
""" Write the equilibration protocol
Writes the equilibration protocol and files into a folder for execution
using files inside the inputdir directory
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a build process.
outputdir : str
Directory where to write the equilibration setup files.
Examples
--------
>>> md = Equilibration()
>>> md.write('./build','./equil')
"""
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits,
'timesteps',
self.runtime,
timestep=self.acemd.timestep)
pdbfile = os.path.join(inputdir, self.acemd.coordinates)
inmol = Molecule(pdbfile)
if self.constraintsteps is None:
constrsteps = int(numsteps / 2)
else:
constrsteps = int(self.constraintsteps)
tcl = list(self.acemd.TCL)
tcl[0] = tcl[0].format(
NUMSTEPS=numsteps,
KCONST=self.fb_k,
REFINDEX=' '.join(map(str, inmol.get('index', self.fb_reference))),
SELINDEX=' '.join(map(str, inmol.get('index', self.fb_selection))),
BOX=' '.join(map(str, self.fb_box)),
NVTSTEPS=self.nvtsteps,
CONSTRAINTSTEPS=constrsteps,
TEMPERATURE=self.temperature)
self.acemd.TCL = tcl[0] + tcl[1]
if self.acemd.celldimension is None and self.acemd.extendedsystem is None:
coords = inmol.get('coords', sel='water')
if coords.size == 0: # It's a vacuum simulation
coords = inmol.get('coords', sel='all')
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
dim = dim + 12.
else:
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
self.acemd.celldimension = '{} {} {}'.format(
dim[0], dim[1], dim[2])
if self.useconstantratio:
self.acemd.useconstantratio = 'on'
self.acemd.setup(inputdir, outputdir, overwrite=True)
# Adding constraints
inmol.set('occupancy', 0)
inmol.set('beta', 0)
for sel in self.constraints:
inmol.set('beta', self.constraints[sel], sel)
outfile = os.path.join(outputdir, self.acemd.coordinates)
inmol.write(outfile)
def write(self, inputdir, outputdir):
""" Write the equilibration protocol
Writes the equilibration protocol and files into a folder for execution
using files inside the inputdir directory
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a build process.
outputdir : str
Directory where to write the equilibration setup files.
Examples
--------
>>> md = Equilibration()
>>> md.write('./build','./equil')
"""
from moleculekit.molecule import Molecule
# Do version consistency check
if (self._version == 2 and not isinstance(self.acemd, Acemd2)) and \
(self._version == 3 and not isinstance(self.acemd, Acemd)):
raise RuntimeError(
'Acemd object version ({}) inconsistent with protocol version at instantiation '
'({})'.format(type(self.acemd), self._version))
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits,
'timesteps',
self.runtime,
timestep=self.acemd.timestep)
if self._version == 3:
self.acemd.temperature = self.temperature
self.acemd.thermostattemperature = self.temperature
self.acemd.run = str(numsteps)
pdbfile = os.path.join(inputdir, self.acemd.coordinates)
inmol = Molecule(pdbfile)
from htmd.builder.builder import detectCisPeptideBonds
detectCisPeptideBonds(inmol)
if np.any(inmol.atomselect('lipids')) and not self.useconstantratio:
logger.warning(
'Lipids detected in input structure. We highly recommend setting useconstantratio=True '
'for membrane simulations.')
if self.constraintsteps is None:
constrsteps = int(numsteps / 2)
else:
constrsteps = int(self.constraintsteps)
if self._version == 2:
if self.restraints:
raise RuntimeWarning(
'restraints are only available on {}(_version=3)'.format(
self.__class__.__name__))
if isinstance(self.acemd.TCL, tuple):
tcl = list(self.acemd.TCL)
tcl[0] = tcl[0].format(
NUMSTEPS=numsteps,
KCONST=self.fb_k,
REFINDEX=' '.join(
map(str, inmol.get('index', self.fb_reference))),
SELINDEX=' '.join(
map(str, inmol.get('index', self.fb_selection))),
BOX=' '.join(map(str, self.fb_box)),
NVTSTEPS=self.nvtsteps,
CONSTRAINTSTEPS=constrsteps,
TEMPERATURE=self.temperature)
self.acemd.TCL = tcl[0] + tcl[1]
else:
logger.warning('{} default TCL was already formatted.'.format(
self.__class__.__name__))
elif self._version == 3:
if self.restraints is not None:
logger.info(
'Using user-provided restraints and ignoring constraints and fb_potential'
)
self.acemd.restraints = self.restraints
else:
logger.warning(
'Converting constraints and fb_potential to restraints. This is a convenience '
'functional conversion. We recommend start using restraints with '
'{}(_version=3)'.format(self.__class__.__name__))
restraints = list()
# convert constraints to restraints and add them
if self.constraints is not None:
restraints += self._constraints2restraints(constrsteps)
# convert fb_potential to restraints and add them
if self.fb_k > 0:
restraints += self._fb_potential2restraints(inputdir)
self.acemd.restraints = restraints
if ((self._version == 2) and self.acemd.celldimension is None and self.acemd.extendedsystem is None) or \
((self._version == 3) and self.acemd.boxsize is None and self.acemd.extendedsystem is None):
coords = inmol.get('coords', sel='water')
if coords.size == 0: # It's a vacuum simulation
coords = inmol.get('coords', sel='all')
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
dim += 12.
else:
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
if self._version == 2:
self.acemd.celldimension = '{} {} {}'.format(
dim[0], dim[1], dim[2])
else:
self.acemd.boxsize = '{} {} {}'.format(dim[0], dim[1], dim[2])
if self.useconstantratio:
self.acemd.useconstantratio = 'on'
self.acemd.setup(inputdir, outputdir, overwrite=True)
if self._version == 2:
# Adding constraints by writing them to the consref file
inconsreffile = os.path.join(inputdir, self.acemd.consref)
consrefmol = Molecule(inconsreffile)
consrefmol.set('occupancy', 0)
consrefmol.set('beta', 0)
if len(self.constraints) == 0:
raise RuntimeError(
'You have not defined any constraints for the {} ('
'constraints={{}}).'.format(self.__class__.__name__))
else:
for sel in self.constraints:
consrefmol.set('beta', self.constraints[sel], sel)
outconsreffile = os.path.join(outputdir, self.acemd.consref)
consrefmol.write(outconsreffile)
def write(self, inputdir, outputdir):
""" Writes the production protocol and files into a folder.
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a equilibration process.
outputdir : str
Directory where to write the production setup files.
"""
from htmd.molecule.molecule import Molecule
# Do version consistency check
if (self._version == 2 and not isinstance(self.acemd, Acemd2)) and \
(self._version == 3 and not isinstance(self.acemd, Acemd)):
raise RuntimeError('Acemd object version ({}) inconsistent with protocol version at instantiation '
'({})'.format(type(self.acemd), self._version))
self._findFiles(inputdir)
self._amberFixes()
if self._version == 2:
self.acemd.temperature = str(self.temperature)
self.acemd.langevintemp = str(self.temperature)
elif self._version == 3:
self.acemd.temperature = self.temperature
self.acemd.thermostattemp = self.temperature
from htmd.units import convert
numsteps = convert(self.timeunits, 'timesteps', self.runtime, timestep=self.acemd.timestep)
if self._version == 3:
self.acemd.run = str(numsteps)
pdbfile = os.path.join(inputdir, self.acemd.coordinates)
inmol = Molecule(pdbfile)
if np.any(inmol.atomselect('lipids')) and not self.useconstantratio:
logger.warning('Lipids detected in input structure. We highly recommend setting useconstantratio=True '
'for membrane simulations.')
if self._version == 2:
if self.restraints:
raise RuntimeWarning('restraints are only available on {}(_version=3)'.format(self.__class__.__name__))
if self.fb_k > 0: # use TCL only for flatbottom
self.acemd.tclforces = 'on'
if isinstance(self.acemd.TCL, tuple):
tcl = list(self.acemd.TCL)
tcl[0] = tcl[0].format(NUMSTEPS=numsteps, TEMPERATURE=self.temperature, KCONST=self.fb_k,
REFINDEX=' '.join(map(str, inmol.get('index', self.fb_reference))),
SELINDEX=' '.join(map(str, inmol.get('index', self.fb_selection))),
BOX=' '.join(map(str, self.fb_box)))
self.acemd.TCL = tcl[0] + tcl[1]
else:
logger.warning('{} default TCL was already formatted.'.format(self.__class__.__name__))
else:
self.acemd.TCL = 'set numsteps {NUMSTEPS}\n'.format(NUMSTEPS=numsteps)
if self.useconstraints:
# Turn on constraints
self.acemd.constraints = 'on'
self.acemd.constraintscaling = '1.0'
else:
if len(self.constraints) != 0:
logger.warning('You have setup constraints to {} but constraints are turned off. '
'If you want to use constraints, define '
'useconstraints=True'.format(self.constraints))
elif self._version == 3:
if self.restraints is not None:
logger.info('Using user-provided restraints and ignoring constraints and fb_potential')
self.acemd.restraints = self.restraints
else:
restraints = list()
if self.fb_k > 0:
logger.warning('Converting fb_potential to restraints. This is a convenience '
'functional conversion. We recommend start using restraints with '
'{}(_version=3)'.format(self.__class__.__name__))
restraints += self._fb_potential2restraints(inputdir)
if self.useconstraints:
logger.warning('Converting constraints to restraints. This is a convenience '
'functional conversion. We recommend start using restraints with '
'{}(_version=3)'.format(self.__class__.__name__))
restraints += self._constraints2restraints()
else:
if len(self.constraints) != 0:
logger.warning('You have setup constraints to {} but constraints are turned off. '
'If you want to use constraints, define '
'useconstraints=True'.format(self.constraints))
if len(restraints) != 0:
self.acemd.restraints = restraints
if self.useconstantratio:
self.acemd.useconstantratio = 'on'
if self.adaptive:
self.acemd.binvelocities = None
self.acemd.setup(inputdir, outputdir, overwrite=True)
if self._version == 2:
# Adding constraints by writing them to the consref file
if self.useconstraints:
inconsreffile = os.path.join(inputdir, self.acemd.consref)
consrefmol = Molecule(inconsreffile)
consrefmol.set('occupancy', 0)
consrefmol.set('beta', 0)
if len(self.constraints) == 0:
raise RuntimeError('You have set the production to use constraints (useconstraints=True), but have '
'not defined any constraints (constraints={}).')
else:
for sel in self.constraints:
consrefmol.set('beta', self.constraints[sel], sel)
outconsreffile = os.path.join(outputdir, self.acemd.consref)
consrefmol.write(outconsreffile)
def write(self, inputdir, outputdir):
""" Write the equilibration protocol
Writes the equilibration protocol and files into a folder for execution
using files inside the inputdir directory
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a build process.
outputdir : str
Directory where to write the equilibration setup files.
Examples
--------
>>> md = Equilibration()
>>> md.write('./build','./equil')
"""
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits,
'timesteps',
self.runtime,
timestep=self.acemd.timestep)
self.acemd.temperature = self.temperature
self.acemd.thermostattemp = self.temperature
self.acemd.run = str(numsteps)
if self.constraintsteps is None:
constrsteps = int(numsteps / 2)
else:
constrsteps = int(self.constraintsteps)
# Adding the default restraints of the equilibration
restraints = list()
restraints.append(
AtomRestraint('protein and noh and not name CA', 0,
[(0.1, 0), (0, constrsteps)]))
restraints.append(
AtomRestraint('protein and name CA', 0, [(1, 0),
(0, constrsteps)]))
if self.restraints is not None:
restraints += self.restraints
self.acemd.restraints = restraints
if self.acemd.celldimension is None and self.acemd.extendedsystem is None:
inmol = Molecule(os.path.join(inputdir, self.acemd.coordinates))
coords = inmol.get('coords', sel='water')
if coords.size == 0: # It's a vacuum simulation
coords = inmol.get('coords', sel='all')
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
dim = dim + 12.
else:
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
self.acemd.celldimension = '{} {} {}'.format(
dim[0], dim[1], dim[2])
if self.useconstantratio:
self.acemd.useconstantratio = 'on'
self.acemd.setup(inputdir, outputdir, overwrite=True)
def write(self, inputdir, outputdir):
""" Write the equilibration protocol
Writes the equilibration protocol and files into a folder for execution
using files inside the inputdir directory
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a build process.
outputdir : str
Directory where to write the equilibration setup files.
Examples
--------
>>> md = Equilibration()
>>> md.write('./build','./equil')
"""
from htmd.molecule.molecule import Molecule
# Do version consistency check
if (self._version == 2 and not isinstance(self.acemd, Acemd2)) and \
(self._version == 3 and not isinstance(self.acemd, Acemd)):
raise RuntimeError('Acemd object version ({}) inconsistent with protocol version at instantiation '
'({})'.format(type(self.acemd), self._version))
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits, 'timesteps', self.runtime, timestep=self.acemd.timestep)
if self._version == 3:
self.acemd.temperature = self.temperature
self.acemd.thermostattemp = self.temperature
self.acemd.run = str(numsteps)
pdbfile = os.path.join(inputdir, self.acemd.coordinates)
inmol = Molecule(pdbfile)
if np.any(inmol.atomselect('lipids')) and not self.useconstantratio:
logger.warning('Lipids detected in input structure. We highly recommend setting useconstantratio=True '
'for membrane simulations.')
if self.constraintsteps is None:
constrsteps = int(numsteps / 2)
else:
constrsteps = int(self.constraintsteps)
if self._version == 2:
if self.restraints:
raise RuntimeWarning('restraints are only available on {}(_version=3)'.format(self.__class__.__name__))
if isinstance(self.acemd.TCL, tuple):
tcl = list(self.acemd.TCL)
tcl[0] = tcl[0].format(NUMSTEPS=numsteps, KCONST=self.fb_k,
REFINDEX=' '.join(map(str, inmol.get('index', self.fb_reference))),
SELINDEX=' '.join(map(str, inmol.get('index', self.fb_selection))),
BOX=' '.join(map(str, self.fb_box)),
NVTSTEPS=self.nvtsteps, CONSTRAINTSTEPS=constrsteps, TEMPERATURE=self.temperature)
self.acemd.TCL = tcl[0] + tcl[1]
else:
logger.warning('{} default TCL was already formatted.'.format(self.__class__.__name__))
elif self._version == 3:
if self.restraints is not None:
logger.info('Using user-provided restraints and ignoring constraints and fb_potential')
self.acemd.restraints = self.restraints
else:
logger.warning('Converting constraints and fb_potential to restraints. This is a convenience '
'functional conversion. We recommend start using restraints with '
'{}(_version=3)'.format(self.__class__.__name__))
restraints = list()
# convert constraints to restraints and add them
if self.constraints is not None:
restraints += self._constraints2restraints(constrsteps)
# convert fb_potential to restraints and add them
if self.fb_k > 0:
restraints += self._fb_potential2restraints(inputdir)
self.acemd.restraints = restraints
if self.acemd.celldimension is None and self.acemd.extendedsystem is None:
coords = inmol.get('coords', sel='water')
if coords.size == 0: # It's a vacuum simulation
coords = inmol.get('coords', sel='all')
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
dim += 12.
else:
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
self.acemd.celldimension = '{} {} {}'.format(dim[0], dim[1], dim[2])
if self.useconstantratio:
self.acemd.useconstantratio = 'on'
self.acemd.setup(inputdir, outputdir, overwrite=True)
if self._version == 2:
# Adding constraints by writing them to the consref file
inconsreffile = os.path.join(inputdir, self.acemd.consref)
consrefmol = Molecule(inconsreffile)
consrefmol.set('occupancy', 0)
consrefmol.set('beta', 0)
if len(self.constraints) == 0:
raise RuntimeError('You have not defined any constraints for the {} ('
'constraints={{}}).'.format(self.__class__.__name__))
else:
for sel in self.constraints:
consrefmol.set('beta', self.constraints[sel], sel)
outconsreffile = os.path.join(outputdir, self.acemd.consref)
consrefmol.write(outconsreffile)
def write(self, inputdir, outputdir):
""" Write the equilibration protocol
Writes the equilibration protocol and files into a folder for execution
using files inside the inputdir directory
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a build process.
outputdir : str
Directory where to write the equilibration setup files.
Examples
--------
>>> md = Equilibration()
>>> md.write('./build','./equil')
"""
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits,
'timesteps',
self.runtime,
timestep=self.acemd.timestep)
pdbfile = os.path.join(inputdir, self.acemd.coordinates)
inmol = Molecule(pdbfile)
if np.any(inmol.atomselect('lipids')) and not self.useconstantratio:
logger.warning(
'Lipids detected in input structure. We highly recommend setting useconstantratio=True '
'for membrane simulations.')
if self.constraintsteps is None:
constrsteps = int(numsteps / 2)
else:
constrsteps = int(self.constraintsteps)
if isinstance(self.acemd.TCL, tuple):
tcl = list(self.acemd.TCL)
tcl[0] = tcl[0].format(
NUMSTEPS=numsteps,
KCONST=self.fb_k,
REFINDEX=' '.join(
map(str, inmol.get('index', self.fb_reference))),
SELINDEX=' '.join(
map(str, inmol.get('index', self.fb_selection))),
BOX=' '.join(map(str, self.fb_box)),
NVTSTEPS=self.nvtsteps,
CONSTRAINTSTEPS=constrsteps,
TEMPERATURE=self.temperature)
self.acemd.TCL = tcl[0] + tcl[1]
else:
logger.warning('{} default TCL was already formatted.'.format(
self.__class__.__name__))
if self.acemd.celldimension is None and self.acemd.extendedsystem is None:
coords = inmol.get('coords', sel='water')
if coords.size == 0: # It's a vacuum simulation
coords = inmol.get('coords', sel='all')
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
dim = dim + 12.
else:
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
self.acemd.celldimension = '{} {} {}'.format(
dim[0], dim[1], dim[2])
if self.useconstantratio:
self.acemd.useconstantratio = 'on'
self.acemd.setup(inputdir, outputdir, overwrite=True)
# Adding constraints by writing them to the consref file
inconsreffile = os.path.join(inputdir, self.acemd.consref)
consrefmol = Molecule(inconsreffile)
consrefmol.set('occupancy', 0)
consrefmol.set('beta', 0)
if len(self.constraints) == 0:
raise RuntimeError(
'You have not defined any constraints for the Equilibration (constraints={}).'
)
else:
for sel in self.constraints:
consrefmol.set('beta', self.constraints[sel], sel)
outconsreffile = os.path.join(outputdir, self.acemd.consref)
consrefmol.write(outconsreffile)
def write(self, inputdir, outputdir, cisbondcheck=True):
"""Writes the production protocol and files into a folder.
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a equilibration process.
outputdir : str
Directory where to write the production setup files.
cisbondcheck : bool
Set to False to disable the cis peptidic bond checks
"""
from moleculekit.molecule import Molecule
from htmd.units import convert
from htmd.builder.builder import detectCisPeptideBonds
self._findFiles(inputdir)
self._amberFixes()
self.acemd.temperature = self.temperature
self.acemd.thermostattemperature = self.temperature
numsteps = convert(self.timeunits,
"timesteps",
self.runtime,
timestep=self.acemd.timestep)
self.acemd.run = str(numsteps)
structfile = os.path.join(inputdir, self.acemd.structure)
pdbfile = os.path.join(inputdir, self.acemd.coordinates)
inmol = Molecule([structfile, pdbfile])
if cisbondcheck:
detectCisPeptideBonds(inmol, respect_bonds=True)
if np.any(inmol.atomselect("lipids")) and not self.useconstantratio:
logger.warning(
"Lipids detected in input structure. We highly recommend setting useconstantratio=True "
"for membrane simulations.")
if self.restraints is not None:
logger.info(
"Using user-provided restraints and ignoring constraints and fb_potential"
)
self.acemd.restraints = self.restraints
else:
restraints = list()
if self.fb_k > 0:
logger.warning(
"Converting fb_potential to restraints. This is a convenience "
"functional conversion. We recommend to start using restraints."
)
restraints += self._fb_potential2restraints(inputdir)
if self.useconstraints:
logger.warning(
"Converting constraints to restraints. This is a convenience "
"functional conversion. We recommend to start using restraints"
)
restraints += self._constraints2restraints()
else:
if len(self.constraints) != 0:
logger.warning(
"You have setup constraints to {} but constraints are turned off. "
"If you want to use constraints, define "
"useconstraints=True".format(self.constraints))
if len(restraints) != 0:
self.acemd.restraints = restraints
if self.useconstantratio:
self.acemd.barostatconstratio = "on"
if self.adaptive:
self.acemd.binvelocities = None
self.acemd.setup(inputdir, outputdir, overwrite=True)
def write(self, inputdir, outputdir):
""" Writes the production protocol and files into a folder.
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a equilibration process.
outputdir : str
Directory where to write the production setup files.
"""
from moleculekit.molecule import Molecule
# Do version consistency check
if (self._version == 2 and not isinstance(self.acemd, Acemd2)) and \
(self._version == 3 and not isinstance(self.acemd, Acemd)):
raise RuntimeError(
'Acemd object version ({}) inconsistent with protocol version at instantiation '
'({})'.format(type(self.acemd), self._version))
self._findFiles(inputdir)
self._amberFixes()
if self._version == 2:
self.acemd.temperature = str(self.temperature)
self.acemd.langevintemp = str(self.temperature)
elif self._version == 3:
self.acemd.temperature = self.temperature
self.acemd.thermostattemp = self.temperature
from htmd.units import convert
numsteps = convert(self.timeunits,
'timesteps',
self.runtime,
timestep=self.acemd.timestep)
if self._version == 3:
self.acemd.run = str(numsteps)
pdbfile = os.path.join(inputdir, self.acemd.coordinates)
inmol = Molecule(pdbfile)
if np.any(inmol.atomselect('lipids')) and not self.useconstantratio:
logger.warning(
'Lipids detected in input structure. We highly recommend setting useconstantratio=True '
'for membrane simulations.')
if self._version == 2:
if self.restraints:
raise RuntimeWarning(
'restraints are only available on {}(_version=3)'.format(
self.__class__.__name__))
if self.fb_k > 0: # use TCL only for flatbottom
self.acemd.tclforces = 'on'
if isinstance(self.acemd.TCL, tuple):
tcl = list(self.acemd.TCL)
tcl[0] = tcl[0].format(
NUMSTEPS=numsteps,
TEMPERATURE=self.temperature,
KCONST=self.fb_k,
REFINDEX=' '.join(
map(str, inmol.get('index', self.fb_reference))),
SELINDEX=' '.join(
map(str, inmol.get('index', self.fb_selection))),
BOX=' '.join(map(str, self.fb_box)))
self.acemd.TCL = tcl[0] + tcl[1]
else:
logger.warning(
'{} default TCL was already formatted.'.format(
self.__class__.__name__))
else:
self.acemd.TCL = 'set numsteps {NUMSTEPS}\n'.format(
NUMSTEPS=numsteps)
if self.useconstraints:
# Turn on constraints
self.acemd.constraints = 'on'
self.acemd.constraintscaling = '1.0'
else:
if len(self.constraints) != 0:
logger.warning(
'You have setup constraints to {} but constraints are turned off. '
'If you want to use constraints, define '
'useconstraints=True'.format(self.constraints))
elif self._version == 3:
if self.restraints is not None:
logger.info(
'Using user-provided restraints and ignoring constraints and fb_potential'
)
self.acemd.restraints = self.restraints
else:
restraints = list()
if self.fb_k > 0:
logger.warning(
'Converting fb_potential to restraints. This is a convenience '
'functional conversion. We recommend start using restraints with '
'{}(_version=3)'.format(self.__class__.__name__))
restraints += self._fb_potential2restraints(inputdir)
if self.useconstraints:
logger.warning(
'Converting constraints to restraints. This is a convenience '
'functional conversion. We recommend start using restraints with '
'{}(_version=3)'.format(self.__class__.__name__))
restraints += self._constraints2restraints()
else:
if len(self.constraints) != 0:
logger.warning(
'You have setup constraints to {} but constraints are turned off. '
'If you want to use constraints, define '
'useconstraints=True'.format(self.constraints))
if len(restraints) != 0:
self.acemd.restraints = restraints
if self.useconstantratio:
self.acemd.useconstantratio = 'on'
if self.adaptive:
self.acemd.binvelocities = None
self.acemd.setup(inputdir, outputdir, overwrite=True)
if self._version == 2:
# Adding constraints by writing them to the consref file
if self.useconstraints:
inconsreffile = os.path.join(inputdir, self.acemd.consref)
consrefmol = Molecule(inconsreffile)
consrefmol.set('occupancy', 0)
consrefmol.set('beta', 0)
if len(self.constraints) == 0:
raise RuntimeError(
'You have set the production to use constraints (useconstraints=True), but have '
'not defined any constraints (constraints={}).')
else:
for sel in self.constraints:
consrefmol.set('beta', self.constraints[sel], sel)
outconsreffile = os.path.join(outputdir, self.acemd.consref)
consrefmol.write(outconsreffile)
def write(self, inputdir, outputdir):
"""Write the equilibration protocol
Writes the equilibration protocol and files into a folder for execution
using files inside the inputdir directory
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a build process.
outputdir : str
Directory where to write the equilibration setup files.
Examples
--------
>>> md = Equilibration()
>>> md.write('./build','./equil')
"""
from moleculekit.molecule import Molecule
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits,
"timesteps",
self.runtime,
timestep=self.acemd.timestep)
self.acemd.temperature = self.temperature
self.acemd.thermostattemperature = self.temperature
self.acemd.run = str(numsteps)
pdbfile = os.path.join(inputdir, self.acemd.coordinates)
inmol = Molecule(pdbfile)
from htmd.builder.builder import detectCisPeptideBonds
detectCisPeptideBonds(inmol)
if np.any(inmol.atomselect("lipids")) and not self.useconstantratio:
logger.warning(
"Lipids detected in input structure. We highly recommend setting useconstantratio=True "
"for membrane simulations.")
if self.restraintsteps is None:
constrsteps = int(numsteps / 2)
else:
constrsteps = int(self.restraintsteps)
if self.restraints is not None:
self.acemd.restraints = self.restraints
else:
self.acemd.restraints = self.defaultEquilRestraints(constrsteps,
mol=inmol)
if self.acemd.boxsize is None and self.acemd.extendedsystem is None:
coords = inmol.get("coords", sel="water")
if coords.size == 0: # It's a vacuum simulation
coords = inmol.get("coords", sel="all")
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
dim += 12.0
else:
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
self.acemd.boxsize = "{} {} {}".format(dim[0], dim[1], dim[2])
if self.useconstantratio:
self.acemd.useconstantratio = "on"
self.acemd.setup(inputdir, outputdir, overwrite=True)